/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.4.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

#define PY_SSIZE_T_CLEAN



#define SWIG_VERSION 0x040400
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_coin"
/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif


#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "5"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows returning the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporary objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next array of casts | pointer to cast hashed by value */
  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
 * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
 */
SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
  const unsigned char *data = (const unsigned char *)str;
  unsigned int hash = len, i = 0, k;
  int rem = (int)len;

  while (rem >= (int)sizeof(unsigned int)) {
    k = *(unsigned int *)data;
    k += i++;
    hash ^= k;
    hash *= 171717;
    data += sizeof(unsigned int);
    rem -= sizeof(unsigned int);
  }

  switch (rem) {
    case 3: k = (unsigned int)(data[2]) << 16;
            k |= (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 2: k = (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 1: k = (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
  }
  return hash;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  static const unsigned int scan_threshold = 4;
  if (ty) {
    swig_cast_info *head = ty->cast;
    unsigned int hash_value = 0;
    int hashed = 0;

    while (head) {

      if (strcmp(head->type->name, c) == 0) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;
        int search = 1;

        if (!hashed) {
          if (head->value < scan_threshold) {
            for (iter = first; iter <= last; iter++) {
              if (strcmp(iter->type->name, c) == 0) {
                return iter;
              }
            }
            search = 0;
          } else {
            hashed = 1;
            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
          }
        }

        if (search) {
          /* Binary search over sorted <'next'|'value'> pairs */
          do {
            iter = first + ((last - first) >> 1);
            if (iter->value < hash_value) {
              first = iter + 1;
            } else if (iter->value == hash_value) {

              if (strcmp(iter->next->type->name, c) == 0) {
                return iter->next;
              }

              /* Hash collision check */
              for (last = iter + 1; last->next && last->value == hash_value; last++) {
                if (strcmp(last->next->type->name, c) == 0) {
                  return last->next;
                }
              }
              for (first = iter - 1; first != head && first->value == hash_value; first--) {
                if (strcmp(first->next->type->name, c) == 0) {
                  return first->next;
                }
              }
              break;
            } else
              last = iter - 1;
          } while (first <= last);
        }
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Check the type by type address
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *head = ty->cast;
    while (head) {
      if (head->type == from) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;

        /* Binary search over sorted array of casts */
        do {
          iter = first + ((last - first) >> 1);
          if (iter->type < from) {
            first = iter + 1;
          } else if (iter->type == from) {
            return iter;
          } else
            last = iter - 1;
        } while (first <= last);
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *head = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (head) {
    swig_cast_info *cast;
    for (cast = head; (cast - head) <= head->value; cast++) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
          SWIG_TypeClientData(tc, clientdata);
        }
      }
    }
    head = head->next;
  }
}

SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


#if PY_VERSION_HEX >= 0x03030000 && !defined(SWIG_NO_HEAPTYPES)
#if !defined(SWIG_HEAPTYPES)
#define SWIG_HEAPTYPES
#endif
#endif

/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif

#if defined(SWIG_HEAPTYPES)
#if PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#include <stddef.h> /* For offsetof */


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

SWIGINTERN PyObject *
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

#if defined(Py_LIMITED_API)
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX < 0x030d00a6
SWIGINTERN PyObject *
SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) {
  PyObject *result = NULL;
  PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__");
  if (qualname) {
    PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__");
    if (mod) {
      if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) {
        result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname);
        SWIG_Py_DECREF(qualname);
      } else {
        result = qualname;
      }
      SWIG_Py_DECREF(mod);
    } else {
      result = qualname;
    }
  }

  return result;
}
#else
# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#endif
#endif

/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */
#if PY_VERSION_HEX < 0x030d00a4
SWIGINTERN PyObject *
SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) {
  PyObject *item = PyList_GetItem(op, index);
  Py_XINCREF(item);
  return item;
}
#else
# define SWIG_PyList_GetItemRef PyList_GetItemRef
#endif

/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1
   functions are renamed here for compatibility with abi3audit */
#if PY_VERSION_HEX < 0x030d00a1
SWIGINTERN int
SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
#if PY_VERSION_HEX >= 0x03000000
  PyObject *item = PyDict_GetItemWithError(mp, key);
#else
  PyObject *item = _PyDict_GetItemWithError(mp, key);
#endif
  if (item != NULL) {
    *result = (PyObject *)(item);
    SWIG_Py_INCREF(*result);
    return 1;
  }
  if (!PyErr_Occurred()) {
    *result = NULL;
    return 0;
  }
  *result = NULL;
  return -1;
}

SWIGINTERN int
SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
  int res;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *key_obj = PyUnicode_FromString(key);
#else
  PyObject *key_obj = PyString_FromString(key);
#endif
  if (key_obj == NULL) {
    *result = NULL;
    return -1;
  }
  res = SWIG_PyDict_GetItemRef(mp, key_obj, result);
  Py_DECREF(key_obj);
  return res;
}
#else
# define SWIG_PyDict_GetItemRef PyDict_GetItemRef
# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  case SWIG_NullReferenceError:
    type = PyExc_TypeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, traceback);
    }
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03050000
# error "This version of SWIG only supports Python 3 >= 3.5"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   

/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  SWIG_Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
}

#endif

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
  if (!Swig_runtime_data_module_global) {
#if PY_VERSION_HEX >= 0x030d0000
    /* free-threading note: the GIL is always enabled when this function is first called
       by SWIG_init, so there's no risk of race conditions */
    Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#elif PY_VERSION_HEX >= 0x03000000
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#else
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
  }
  assert(Swig_runtime_data_module_global);
  return Swig_runtime_data_module_global;
}

/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_doc,                    /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
  return type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data)
{
  SWIG_Py_XDECREF(data->klass);
  SWIG_Py_XDECREF(data->newraw);
  SWIG_Py_XDECREF(data->newargs);
  SWIG_Py_XDECREF(data->destroy);
  free(data);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
  PyObject *swigdict;
  PyObject *weakreflist;
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->swigdict)
    sobj->swigdict = PyDict_New();

  SWIG_Py_XINCREF(sobj->swigdict);
  return sobj->swigdict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
        res = PyUnicode_Format(ofmt,args);
#else
        res = PyString_Format(ofmt,args);
#endif
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_Py_DECREF(args);
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  return repr;
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
  /* tp_compare is only called when both objects have the same type, so
   * the casts are guaranteed to be ok. */
  void *i = ((SwigPyObject *)v)->ptr;
  void *j = ((SwigPyObject *)w)->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
     * the first argument is guaranteed to be an instance of SwigPyObject, but the
     * second is not, so we typecheck that one. */
    if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_Type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  /* Only builtin types have SwigPyObject as a base type */
  return PyType_IsSubtype(op_type, target_tp);
#else
  /* Check for an exact match to SwigPyObject */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0;
#endif
  }
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

static PyObject* Swig_Capsule_global = NULL;

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      SWIG_Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
  SWIG_Py_XDECREF(sobj->swigdict);
  PyObject_Free(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
SwigPyObject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyObject",  /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      offsetof(SwigPyObject, weakreflist),  /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_methods,                 /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  static PyMemberDef SwigPyObject_members[] = {
      { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
      { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
      { NULL, 0, 0, 0, NULL }
  };
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { Py_tp_members, (void *)SwigPyObject_members },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
   identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
    /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
  if (pytype) {
    ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
    ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
  }
#endif
#endif
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
    sobj->swigdict = 0;
    sobj->weakreflist = 0;
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyPacked_Type();
  PyTypeObject *op_type = Py_TYPE(op);
  /* Check for an exact match to SwigPyPacked */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0;
#endif
  }
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_Free(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyPacked",  /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyPacked_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_Type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_Free((PyObject *)sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX >= 0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
      Py_DECREF(pyobj);
    else
      pyobj = NULL;
#else
    pyobj = PyWeakref_GetObject(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
      if (PyWeakref_CheckProxy(pyobj)) {
        PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
      obj = PyObject_GetAttr(pyobj, SWIG_This());
      if (obj) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj, SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 0;
      }
      res = SWIG_OK;
    }
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            SWIG_Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      if (newobj) {
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    SWIG_Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  }
#else
  void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
  if (PyErr_Occurred()) {
    PyErr_Clear();
    type_pointer = (void *)0;
  }
#endif
  return (swig_module_info *) type_pointer;
}


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i = 0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_PYOBJ_REFCNT(Swig_This_global);
  SWIG_Py_XDECREF(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  SWIG_Py_XDECREF(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  SWIG_Py_XDECREF(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  swig_type_info *descriptor;
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *obj;
  SWIG_PyDict_GetItemStringRef(cache, type, &obj);
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) PyDict_SetItemString(cache, type, obj);
    }
  }
  SWIG_Py_XDECREF(obj);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = Py_TYPE(obj);
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
    SWIG_Py_DECREF(tpname);
#else
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%s'", Py_TYPE(name)->tp_name);
#endif
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) != 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = Py_TYPE(descr)->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
#if PY_VERSION_HEX >= 0x03000000
    {
      PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(tp);
      PyErr_Format(PyExc_AttributeError, "'%S' object has no attribute '%s'", tpname, PyString_AsString(encoded_name));
      SWIG_Py_DECREF(tpname);
    }
#else
    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyString_AsString(encoded_name));
#endif
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_AttributeApplyFunc swig_types[0]
#define SWIGTYPE_p_ContextDestructionCB swig_types[1]
#define SWIGTYPE_p_FILE swig_types[2]
#define SWIGTYPE_p_Key swig_types[3]
#define SWIGTYPE_p_ProgressCallbackType swig_types[4]
#define SWIGTYPE_p_SbBSPTree swig_types[5]
#define SWIGTYPE_p_SbBarrier swig_types[6]
#define SWIGTYPE_p_SbBox2d swig_types[7]
#define SWIGTYPE_p_SbBox2f swig_types[8]
#define SWIGTYPE_p_SbBox2i32 swig_types[9]
#define SWIGTYPE_p_SbBox2s swig_types[10]
#define SWIGTYPE_p_SbBox3d swig_types[11]
#define SWIGTYPE_p_SbBox3f swig_types[12]
#define SWIGTYPE_p_SbBox3i32 swig_types[13]
#define SWIGTYPE_p_SbBox3s swig_types[14]
#define SWIGTYPE_p_SbByteBuffer swig_types[15]
#define SWIGTYPE_p_SbClip swig_types[16]
#define SWIGTYPE_p_SbColor swig_types[17]
#define SWIGTYPE_p_SbColor4f swig_types[18]
#define SWIGTYPE_p_SbCondVar swig_types[19]
#define SWIGTYPE_p_SbCylinder swig_types[20]
#define SWIGTYPE_p_SbCylinderPlaneProjector swig_types[21]
#define SWIGTYPE_p_SbCylinderProjector swig_types[22]
#define SWIGTYPE_p_SbCylinderSectionProjector swig_types[23]
#define SWIGTYPE_p_SbCylinderSheetProjector swig_types[24]
#define SWIGTYPE_p_SbDPLine swig_types[25]
#define SWIGTYPE_p_SbDPMatrix swig_types[26]
#define SWIGTYPE_p_SbDPPlane swig_types[27]
#define SWIGTYPE_p_SbDPRotation swig_types[28]
#define SWIGTYPE_p_SbDPViewVolume swig_types[29]
#define SWIGTYPE_p_SbDict swig_types[30]
#define SWIGTYPE_p_SbFifo swig_types[31]
#define SWIGTYPE_p_SbHeap swig_types[32]
#define SWIGTYPE_p_SbHeapFuncs swig_types[33]
#define SWIGTYPE_p_SbImage swig_types[34]
#define SWIGTYPE_p_SbIntList swig_types[35]
#define SWIGTYPE_p_SbLine swig_types[36]
#define SWIGTYPE_p_SbLineProjector swig_types[37]
#define SWIGTYPE_p_SbListT_SbString_t swig_types[38]
#define SWIGTYPE_p_SbListT_char_const_p_t swig_types[39]
#define SWIGTYPE_p_SbListT_int_t swig_types[40]
#define SWIGTYPE_p_SbListT_void_p_t swig_types[41]
#define SWIGTYPE_p_SbMatrix swig_types[42]
#define SWIGTYPE_p_SbMutex swig_types[43]
#define SWIGTYPE_p_SbName swig_types[44]
#define SWIGTYPE_p_SbOctTree swig_types[45]
#define SWIGTYPE_p_SbOctTreeFuncs swig_types[46]
#define SWIGTYPE_p_SbPList swig_types[47]
#define SWIGTYPE_p_SbPlane swig_types[48]
#define SWIGTYPE_p_SbPlaneProjector swig_types[49]
#define SWIGTYPE_p_SbProjector swig_types[50]
#define SWIGTYPE_p_SbRWMutex swig_types[51]
#define SWIGTYPE_p_SbRotation swig_types[52]
#define SWIGTYPE_p_SbSphere swig_types[53]
#define SWIGTYPE_p_SbSpherePlaneProjector swig_types[54]
#define SWIGTYPE_p_SbSphereProjector swig_types[55]
#define SWIGTYPE_p_SbSphereSectionProjector swig_types[56]
#define SWIGTYPE_p_SbSphereSheetProjector swig_types[57]
#define SWIGTYPE_p_SbStorage swig_types[58]
#define SWIGTYPE_p_SbString swig_types[59]
#define SWIGTYPE_p_SbStringList swig_types[60]
#define SWIGTYPE_p_SbTesselator swig_types[61]
#define SWIGTYPE_p_SbThread swig_types[62]
#define SWIGTYPE_p_SbThreadAutoLock swig_types[63]
#define SWIGTYPE_p_SbThreadMutex swig_types[64]
#define SWIGTYPE_p_SbTime swig_types[65]
#define SWIGTYPE_p_SbVec2b swig_types[66]
#define SWIGTYPE_p_SbVec2d swig_types[67]
#define SWIGTYPE_p_SbVec2f swig_types[68]
#define SWIGTYPE_p_SbVec2i32 swig_types[69]
#define SWIGTYPE_p_SbVec2s swig_types[70]
#define SWIGTYPE_p_SbVec2ub swig_types[71]
#define SWIGTYPE_p_SbVec2ui32 swig_types[72]
#define SWIGTYPE_p_SbVec2us swig_types[73]
#define SWIGTYPE_p_SbVec3b swig_types[74]
#define SWIGTYPE_p_SbVec3d swig_types[75]
#define SWIGTYPE_p_SbVec3f swig_types[76]
#define SWIGTYPE_p_SbVec3fList swig_types[77]
#define SWIGTYPE_p_SbVec3i32 swig_types[78]
#define SWIGTYPE_p_SbVec3s swig_types[79]
#define SWIGTYPE_p_SbVec3ub swig_types[80]
#define SWIGTYPE_p_SbVec3ui32 swig_types[81]
#define SWIGTYPE_p_SbVec3us swig_types[82]
#define SWIGTYPE_p_SbVec4b swig_types[83]
#define SWIGTYPE_p_SbVec4d swig_types[84]
#define SWIGTYPE_p_SbVec4f swig_types[85]
#define SWIGTYPE_p_SbVec4i32 swig_types[86]
#define SWIGTYPE_p_SbVec4s swig_types[87]
#define SWIGTYPE_p_SbVec4ub swig_types[88]
#define SWIGTYPE_p_SbVec4ui32 swig_types[89]
#define SWIGTYPE_p_SbVec4us swig_types[90]
#define SWIGTYPE_p_SbViewVolume swig_types[91]
#define SWIGTYPE_p_SbViewportRegion swig_types[92]
#define SWIGTYPE_p_SbXfBox3f swig_types[93]
#define SWIGTYPE_p_ScXML swig_types[94]
#define SWIGTYPE_p_ScXMLAbstractStateElt swig_types[95]
#define SWIGTYPE_p_ScXMLAddOpExprDataObj swig_types[96]
#define SWIGTYPE_p_ScXMLAnchorElt swig_types[97]
#define SWIGTYPE_p_ScXMLAndOpExprDataObj swig_types[98]
#define SWIGTYPE_p_ScXMLAppendOpExprDataObj swig_types[99]
#define SWIGTYPE_p_ScXMLAssignElt swig_types[100]
#define SWIGTYPE_p_ScXMLBoolDataObj swig_types[101]
#define SWIGTYPE_p_ScXMLCoinAddOpExprDataObj swig_types[102]
#define SWIGTYPE_p_ScXMLCoinDivideOpExprDataObj swig_types[103]
#define SWIGTYPE_p_ScXMLCoinEqualsOpExprDataObj swig_types[104]
#define SWIGTYPE_p_ScXMLCoinEvaluator swig_types[105]
#define SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj swig_types[106]
#define SWIGTYPE_p_ScXMLCoinMultiplyOpExprDataObj swig_types[107]
#define SWIGTYPE_p_ScXMLCoinSubtractOpExprDataObj swig_types[108]
#define SWIGTYPE_p_ScXMLConstantDataObj swig_types[109]
#define SWIGTYPE_p_ScXMLContentElt swig_types[110]
#define SWIGTYPE_p_ScXMLDataElt swig_types[111]
#define SWIGTYPE_p_ScXMLDataModelElt swig_types[112]
#define SWIGTYPE_p_ScXMLDataObj swig_types[113]
#define SWIGTYPE_p_ScXMLDivideOpExprDataObj swig_types[114]
#define SWIGTYPE_p_ScXMLDocument swig_types[115]
#define SWIGTYPE_p_ScXMLECMAScriptEvaluator swig_types[116]
#define SWIGTYPE_p_ScXMLElseElt swig_types[117]
#define SWIGTYPE_p_ScXMLElseIfElt swig_types[118]
#define SWIGTYPE_p_ScXMLElt swig_types[119]
#define SWIGTYPE_p_ScXMLEltReader swig_types[120]
#define SWIGTYPE_p_ScXMLEqualsOpExprDataObj swig_types[121]
#define SWIGTYPE_p_ScXMLEvaluator swig_types[122]
#define SWIGTYPE_p_ScXMLEvent swig_types[123]
#define SWIGTYPE_p_ScXMLEventElt swig_types[124]
#define SWIGTYPE_p_ScXMLEventTarget swig_types[125]
#define SWIGTYPE_p_ScXMLExecutableElt swig_types[126]
#define SWIGTYPE_p_ScXMLExprDataObj swig_types[127]
#define SWIGTYPE_p_ScXMLFinalElt swig_types[128]
#define SWIGTYPE_p_ScXMLFinalizeElt swig_types[129]
#define SWIGTYPE_p_ScXMLHistoryElt swig_types[130]
#define SWIGTYPE_p_ScXMLIfElt swig_types[131]
#define SWIGTYPE_p_ScXMLInExprDataObj swig_types[132]
#define SWIGTYPE_p_ScXMLInitialElt swig_types[133]
#define SWIGTYPE_p_ScXMLInvokeElt swig_types[134]
#define SWIGTYPE_p_ScXMLLogElt swig_types[135]
#define SWIGTYPE_p_ScXMLMinimumEvaluator swig_types[136]
#define SWIGTYPE_p_ScXMLMinimumExprDataObj swig_types[137]
#define SWIGTYPE_p_ScXMLMultiplyOpExprDataObj swig_types[138]
#define SWIGTYPE_p_ScXMLNegateOpExprDataObj swig_types[139]
#define SWIGTYPE_p_ScXMLNotOpExprDataObj swig_types[140]
#define SWIGTYPE_p_ScXMLObject swig_types[141]
#define SWIGTYPE_p_ScXMLOnEntryElt swig_types[142]
#define SWIGTYPE_p_ScXMLOnExitElt swig_types[143]
#define SWIGTYPE_p_ScXMLOrOpExprDataObj swig_types[144]
#define SWIGTYPE_p_ScXMLParallelElt swig_types[145]
#define SWIGTYPE_p_ScXMLParamElt swig_types[146]
#define SWIGTYPE_p_ScXMLRealDataObj swig_types[147]
#define SWIGTYPE_p_ScXMLReferenceDataObj swig_types[148]
#define SWIGTYPE_p_ScXMLSbDataObj swig_types[149]
#define SWIGTYPE_p_ScXMLScriptElt swig_types[150]
#define SWIGTYPE_p_ScXMLScxmlElt swig_types[151]
#define SWIGTYPE_p_ScXMLSendElt swig_types[152]
#define SWIGTYPE_p_ScXMLStateElt swig_types[153]
#define SWIGTYPE_p_ScXMLStateMachine swig_types[154]
#define SWIGTYPE_p_ScXMLStringDataObj swig_types[155]
#define SWIGTYPE_p_ScXMLSubtractOpExprDataObj swig_types[156]
#define SWIGTYPE_p_ScXMLTransitionElt swig_types[157]
#define SWIGTYPE_p_ScXMLValidateElt swig_types[158]
#define SWIGTYPE_p_ScXMLXMLDataObj swig_types[159]
#define SWIGTYPE_p_ScXMLXPathEvaluator swig_types[160]
#define SWIGTYPE_p_SoAccumulatedElement swig_types[161]
#define SWIGTYPE_p_SoAction swig_types[162]
#define SWIGTYPE_p_SoActionMethodList swig_types[163]
#define SWIGTYPE_p_SoAlarmSensor swig_types[164]
#define SWIGTYPE_p_SoAlphaTest swig_types[165]
#define SWIGTYPE_p_SoAmbientColorElement swig_types[166]
#define SWIGTYPE_p_SoAnnoText3CharOrientElement swig_types[167]
#define SWIGTYPE_p_SoAnnoText3FontSizeHintElement swig_types[168]
#define SWIGTYPE_p_SoAnnoText3RenderPrintElement swig_types[169]
#define SWIGTYPE_p_SoAnnotation swig_types[170]
#define SWIGTYPE_p_SoAntiSquish swig_types[171]
#define SWIGTYPE_p_SoAppearanceKit swig_types[172]
#define SWIGTYPE_p_SoArray swig_types[173]
#define SWIGTYPE_p_SoAsciiText swig_types[174]
#define SWIGTYPE_p_SoAudioDevice swig_types[175]
#define SWIGTYPE_p_SoAudioRenderAction swig_types[176]
#define SWIGTYPE_p_SoAuditorList swig_types[177]
#define SWIGTYPE_p_SoBBoxModelMatrixElement swig_types[178]
#define SWIGTYPE_p_SoBase swig_types[179]
#define SWIGTYPE_p_SoBaseColor swig_types[180]
#define SWIGTYPE_p_SoBaseKit swig_types[181]
#define SWIGTYPE_p_SoBaseList swig_types[182]
#define SWIGTYPE_p_SoBlinker swig_types[183]
#define SWIGTYPE_p_SoBoolOperation swig_types[184]
#define SWIGTYPE_p_SoBoundingBoxCache swig_types[185]
#define SWIGTYPE_p_SoBoxHighlightRenderAction swig_types[186]
#define SWIGTYPE_p_SoBumpMap swig_types[187]
#define SWIGTYPE_p_SoBumpMapCoordinate swig_types[188]
#define SWIGTYPE_p_SoBumpMapCoordinateElement swig_types[189]
#define SWIGTYPE_p_SoBumpMapElement swig_types[190]
#define SWIGTYPE_p_SoBumpMapMatrixElement swig_types[191]
#define SWIGTYPE_p_SoBumpMapTransform swig_types[192]
#define SWIGTYPE_p_SoBundle swig_types[193]
#define SWIGTYPE_p_SoButtonEvent swig_types[194]
#define SWIGTYPE_p_SoByteStream swig_types[195]
#define SWIGTYPE_p_SoCache swig_types[196]
#define SWIGTYPE_p_SoCacheElement swig_types[197]
#define SWIGTYPE_p_SoCacheHint swig_types[198]
#define SWIGTYPE_p_SoCacheHintElement swig_types[199]
#define SWIGTYPE_p_SoCalculator swig_types[200]
#define SWIGTYPE_p_SoCallback swig_types[201]
#define SWIGTYPE_p_SoCallbackAction swig_types[202]
#define SWIGTYPE_p_SoCallbackActionCB swig_types[203]
#define SWIGTYPE_p_SoCallbackList swig_types[204]
#define SWIGTYPE_p_SoCamera swig_types[205]
#define SWIGTYPE_p_SoCameraKit swig_types[206]
#define SWIGTYPE_p_SoCenterballDragger swig_types[207]
#define SWIGTYPE_p_SoCenterballManip swig_types[208]
#define SWIGTYPE_p_SoChildList swig_types[209]
#define SWIGTYPE_p_SoClipPlane swig_types[210]
#define SWIGTYPE_p_SoClipPlaneElement swig_types[211]
#define SWIGTYPE_p_SoClipPlaneManip swig_types[212]
#define SWIGTYPE_p_SoColorIndex swig_types[213]
#define SWIGTYPE_p_SoColorPacker swig_types[214]
#define SWIGTYPE_p_SoComplexity swig_types[215]
#define SWIGTYPE_p_SoComplexityElement swig_types[216]
#define SWIGTYPE_p_SoComplexityTypeElement swig_types[217]
#define SWIGTYPE_p_SoComposeMatrix swig_types[218]
#define SWIGTYPE_p_SoComposeRotation swig_types[219]
#define SWIGTYPE_p_SoComposeRotationFromTo swig_types[220]
#define SWIGTYPE_p_SoComposeVec2f swig_types[221]
#define SWIGTYPE_p_SoComposeVec3f swig_types[222]
#define SWIGTYPE_p_SoComposeVec4f swig_types[223]
#define SWIGTYPE_p_SoComputeBoundingBox swig_types[224]
#define SWIGTYPE_p_SoConcatenate swig_types[225]
#define SWIGTYPE_p_SoCone swig_types[226]
#define SWIGTYPE_p_SoConeDetail swig_types[227]
#define SWIGTYPE_p_SoContextHandler swig_types[228]
#define SWIGTYPE_p_SoConvexDataCache swig_types[229]
#define SWIGTYPE_p_SoCoordinate3 swig_types[230]
#define SWIGTYPE_p_SoCoordinate4 swig_types[231]
#define SWIGTYPE_p_SoCoordinateElement swig_types[232]
#define SWIGTYPE_p_SoCounter swig_types[233]
#define SWIGTYPE_p_SoCreaseAngleElement swig_types[234]
#define SWIGTYPE_p_SoCube swig_types[235]
#define SWIGTYPE_p_SoCubeDetail swig_types[236]
#define SWIGTYPE_p_SoCullElement swig_types[237]
#define SWIGTYPE_p_SoCylinder swig_types[238]
#define SWIGTYPE_p_SoCylinderDetail swig_types[239]
#define SWIGTYPE_p_SoDB swig_types[240]
#define SWIGTYPE_p_SoDataSensor swig_types[241]
#define SWIGTYPE_p_SoDebugError swig_types[242]
#define SWIGTYPE_p_SoDecimationPercentageElement swig_types[243]
#define SWIGTYPE_p_SoDecimationTypeElement swig_types[244]
#define SWIGTYPE_p_SoDecomposeMatrix swig_types[245]
#define SWIGTYPE_p_SoDecomposeRotation swig_types[246]
#define SWIGTYPE_p_SoDecomposeVec2f swig_types[247]
#define SWIGTYPE_p_SoDecomposeVec3f swig_types[248]
#define SWIGTYPE_p_SoDecomposeVec4f swig_types[249]
#define SWIGTYPE_p_SoDelayQueueSensor swig_types[250]
#define SWIGTYPE_p_SoDepthBuffer swig_types[251]
#define SWIGTYPE_p_SoDepthBufferElement swig_types[252]
#define SWIGTYPE_p_SoDepthBufferElement__DepthWriteFunction swig_types[253]
#define SWIGTYPE_p_SoDetail swig_types[254]
#define SWIGTYPE_p_SoDetailList swig_types[255]
#define SWIGTYPE_p_SoDiffuseColorElement swig_types[256]
#define SWIGTYPE_p_SoDirectionalLight swig_types[257]
#define SWIGTYPE_p_SoDirectionalLightDragger swig_types[258]
#define SWIGTYPE_p_SoDirectionalLightManip swig_types[259]
#define SWIGTYPE_p_SoDragPointDragger swig_types[260]
#define SWIGTYPE_p_SoDragger swig_types[261]
#define SWIGTYPE_p_SoDrawStyle swig_types[262]
#define SWIGTYPE_p_SoDrawStyleElement swig_types[263]
#define SWIGTYPE_p_SoElapsedTime swig_types[264]
#define SWIGTYPE_p_SoElement swig_types[265]
#define SWIGTYPE_p_SoEmissiveColorElement swig_types[266]
#define SWIGTYPE_p_SoEnabledElementsList swig_types[267]
#define SWIGTYPE_p_SoEngine swig_types[268]
#define SWIGTYPE_p_SoEngineList swig_types[269]
#define SWIGTYPE_p_SoEngineOutput swig_types[270]
#define SWIGTYPE_p_SoEngineOutputData swig_types[271]
#define SWIGTYPE_p_SoEngineOutputList swig_types[272]
#define SWIGTYPE_p_SoEnvironment swig_types[273]
#define SWIGTYPE_p_SoEnvironmentElement swig_types[274]
#define SWIGTYPE_p_SoError swig_types[275]
#define SWIGTYPE_p_SoEvent swig_types[276]
#define SWIGTYPE_p_SoEventCallback swig_types[277]
#define SWIGTYPE_p_SoEventManager swig_types[278]
#define SWIGTYPE_p_SoExtSelection swig_types[279]
#define SWIGTYPE_p_SoFaceDetail swig_types[280]
#define SWIGTYPE_p_SoFaceSet swig_types[281]
#define SWIGTYPE_p_SoField swig_types[282]
#define SWIGTYPE_p_SoFieldContainer swig_types[283]
#define SWIGTYPE_p_SoFieldConverter swig_types[284]
#define SWIGTYPE_p_SoFieldData swig_types[285]
#define SWIGTYPE_p_SoFieldList swig_types[286]
#define SWIGTYPE_p_SoFieldSensor swig_types[287]
#define SWIGTYPE_p_SoFile swig_types[288]
#define SWIGTYPE_p_SoFloatElement swig_types[289]
#define SWIGTYPE_p_SoFocalDistanceElement swig_types[290]
#define SWIGTYPE_p_SoFont swig_types[291]
#define SWIGTYPE_p_SoFontNameElement swig_types[292]
#define SWIGTYPE_p_SoFontSizeElement swig_types[293]
#define SWIGTYPE_p_SoFontStyle swig_types[294]
#define SWIGTYPE_p_SoFragmentShader swig_types[295]
#define SWIGTYPE_p_SoFrustumCamera swig_types[296]
#define SWIGTYPE_p_SoFullPath swig_types[297]
#define SWIGTYPE_p_SoGLBigImage swig_types[298]
#define SWIGTYPE_p_SoGLCacheContextElement swig_types[299]
#define SWIGTYPE_p_SoGLCacheList swig_types[300]
#define SWIGTYPE_p_SoGLClipPlaneElement swig_types[301]
#define SWIGTYPE_p_SoGLColorIndexElement swig_types[302]
#define SWIGTYPE_p_SoGLCoordinateElement swig_types[303]
#define SWIGTYPE_p_SoGLDepthBufferElement swig_types[304]
#define SWIGTYPE_p_SoGLDisplayList swig_types[305]
#define SWIGTYPE_p_SoGLDrawStyleElement swig_types[306]
#define SWIGTYPE_p_SoGLEnvironmentElement swig_types[307]
#define SWIGTYPE_p_SoGLImage swig_types[308]
#define SWIGTYPE_p_SoGLImageResizeCB swig_types[309]
#define SWIGTYPE_p_SoGLLazyElement swig_types[310]
#define SWIGTYPE_p_SoGLLazyElement__GLState swig_types[311]
#define SWIGTYPE_p_SoGLLightIdElement swig_types[312]
#define SWIGTYPE_p_SoGLLinePatternElement swig_types[313]
#define SWIGTYPE_p_SoGLLineWidthElement swig_types[314]
#define SWIGTYPE_p_SoGLModelMatrixElement swig_types[315]
#define SWIGTYPE_p_SoGLMultiTextureCoordinateElement swig_types[316]
#define SWIGTYPE_p_SoGLMultiTextureEnabledElement swig_types[317]
#define SWIGTYPE_p_SoGLMultiTextureImageElement swig_types[318]
#define SWIGTYPE_p_SoGLMultiTextureMatrixElement swig_types[319]
#define SWIGTYPE_p_SoGLNormalElement swig_types[320]
#define SWIGTYPE_p_SoGLPointSizeElement swig_types[321]
#define SWIGTYPE_p_SoGLPolygonOffsetElement swig_types[322]
#define SWIGTYPE_p_SoGLProjectionMatrixElement swig_types[323]
#define SWIGTYPE_p_SoGLRenderAbortCB swig_types[324]
#define SWIGTYPE_p_SoGLRenderAction swig_types[325]
#define SWIGTYPE_p_SoGLRenderCache swig_types[326]
#define SWIGTYPE_p_SoGLRenderPassElement swig_types[327]
#define SWIGTYPE_p_SoGLShaderObject swig_types[328]
#define SWIGTYPE_p_SoGLShapeHintsElement swig_types[329]
#define SWIGTYPE_p_SoGLUpdateAreaElement swig_types[330]
#define SWIGTYPE_p_SoGLVBOElement swig_types[331]
#define SWIGTYPE_p_SoGLVertexAttributeElement swig_types[332]
#define SWIGTYPE_p_SoGLViewingMatrixElement swig_types[333]
#define SWIGTYPE_p_SoGLViewportRegionElement swig_types[334]
#define SWIGTYPE_p_SoGate swig_types[335]
#define SWIGTYPE_p_SoGeo swig_types[336]
#define SWIGTYPE_p_SoGeoCoordinate swig_types[337]
#define SWIGTYPE_p_SoGeoLocation swig_types[338]
#define SWIGTYPE_p_SoGeoOrigin swig_types[339]
#define SWIGTYPE_p_SoGeoSeparator swig_types[340]
#define SWIGTYPE_p_SoGetBoundingBoxAction swig_types[341]
#define SWIGTYPE_p_SoGetMatrixAction swig_types[342]
#define SWIGTYPE_p_SoGetPrimitiveCountAction swig_types[343]
#define SWIGTYPE_p_SoGlyph swig_types[344]
#define SWIGTYPE_p_SoGroup swig_types[345]
#define SWIGTYPE_p_SoHandleBoxDragger swig_types[346]
#define SWIGTYPE_p_SoHandleBoxManip swig_types[347]
#define SWIGTYPE_p_SoHandleEventAction swig_types[348]
#define SWIGTYPE_p_SoHardCopy swig_types[349]
#define SWIGTYPE_p_SoHeightMapToNormalMap swig_types[350]
#define SWIGTYPE_p_SoIdleSensor swig_types[351]
#define SWIGTYPE_p_SoImage swig_types[352]
#define SWIGTYPE_p_SoIndexedFaceSet swig_types[353]
#define SWIGTYPE_p_SoIndexedLineSet swig_types[354]
#define SWIGTYPE_p_SoIndexedMarkerSet swig_types[355]
#define SWIGTYPE_p_SoIndexedNurbsCurve swig_types[356]
#define SWIGTYPE_p_SoIndexedNurbsSurface swig_types[357]
#define SWIGTYPE_p_SoIndexedPointSet swig_types[358]
#define SWIGTYPE_p_SoIndexedShape swig_types[359]
#define SWIGTYPE_p_SoIndexedTriangleStripSet swig_types[360]
#define SWIGTYPE_p_SoInfo swig_types[361]
#define SWIGTYPE_p_SoInput swig_types[362]
#define SWIGTYPE_p_SoInt32Element swig_types[363]
#define SWIGTYPE_p_SoInteraction swig_types[364]
#define SWIGTYPE_p_SoInteractionKit swig_types[365]
#define SWIGTYPE_p_SoInterpolate swig_types[366]
#define SWIGTYPE_p_SoInterpolateFloat swig_types[367]
#define SWIGTYPE_p_SoInterpolateRotation swig_types[368]
#define SWIGTYPE_p_SoInterpolateVec2f swig_types[369]
#define SWIGTYPE_p_SoInterpolateVec3f swig_types[370]
#define SWIGTYPE_p_SoInterpolateVec4f swig_types[371]
#define SWIGTYPE_p_SoIntersectingPrimitive swig_types[372]
#define SWIGTYPE_p_SoIntersectionCB swig_types[373]
#define SWIGTYPE_p_SoIntersectionDetectionAction swig_types[374]
#define SWIGTYPE_p_SoIntersectionFilterCB swig_types[375]
#define SWIGTYPE_p_SoIntersectionVisitationCB swig_types[376]
#define SWIGTYPE_p_SoJackDragger swig_types[377]
#define SWIGTYPE_p_SoJackManip swig_types[378]
#define SWIGTYPE_p_SoKeyboardEvent swig_types[379]
#define SWIGTYPE_p_SoLOD swig_types[380]
#define SWIGTYPE_p_SoLabel swig_types[381]
#define SWIGTYPE_p_SoLazyElement swig_types[382]
#define SWIGTYPE_p_SoLevelOfDetail swig_types[383]
#define SWIGTYPE_p_SoLight swig_types[384]
#define SWIGTYPE_p_SoLightAttenuationElement swig_types[385]
#define SWIGTYPE_p_SoLightElement swig_types[386]
#define SWIGTYPE_p_SoLightKit swig_types[387]
#define SWIGTYPE_p_SoLightModel swig_types[388]
#define SWIGTYPE_p_SoLightModelElement swig_types[389]
#define SWIGTYPE_p_SoLightPath swig_types[390]
#define SWIGTYPE_p_SoLineDetail swig_types[391]
#define SWIGTYPE_p_SoLineHighlightRenderAction swig_types[392]
#define SWIGTYPE_p_SoLinePatternElement swig_types[393]
#define SWIGTYPE_p_SoLineSet swig_types[394]
#define SWIGTYPE_p_SoLineWidthElement swig_types[395]
#define SWIGTYPE_p_SoLinearProfile swig_types[396]
#define SWIGTYPE_p_SoListener swig_types[397]
#define SWIGTYPE_p_SoListenerDopplerElement swig_types[398]
#define SWIGTYPE_p_SoListenerGainElement swig_types[399]
#define SWIGTYPE_p_SoListenerOrientationElement swig_types[400]
#define SWIGTYPE_p_SoListenerPositionElement swig_types[401]
#define SWIGTYPE_p_SoLocalBBoxMatrixElement swig_types[402]
#define SWIGTYPE_p_SoLocateHighlight swig_types[403]
#define SWIGTYPE_p_SoLocation2Event swig_types[404]
#define SWIGTYPE_p_SoLockManager swig_types[405]
#define SWIGTYPE_p_SoMFBitMask swig_types[406]
#define SWIGTYPE_p_SoMFBool swig_types[407]
#define SWIGTYPE_p_SoMFColor swig_types[408]
#define SWIGTYPE_p_SoMFColorRGBA swig_types[409]
#define SWIGTYPE_p_SoMFDouble swig_types[410]
#define SWIGTYPE_p_SoMFEngine swig_types[411]
#define SWIGTYPE_p_SoMFEnum swig_types[412]
#define SWIGTYPE_p_SoMFFloat swig_types[413]
#define SWIGTYPE_p_SoMFInt32 swig_types[414]
#define SWIGTYPE_p_SoMFMatrix swig_types[415]
#define SWIGTYPE_p_SoMFName swig_types[416]
#define SWIGTYPE_p_SoMFNode swig_types[417]
#define SWIGTYPE_p_SoMFPath swig_types[418]
#define SWIGTYPE_p_SoMFPlane swig_types[419]
#define SWIGTYPE_p_SoMFRotation swig_types[420]
#define SWIGTYPE_p_SoMFShort swig_types[421]
#define SWIGTYPE_p_SoMFString swig_types[422]
#define SWIGTYPE_p_SoMFTime swig_types[423]
#define SWIGTYPE_p_SoMFUInt32 swig_types[424]
#define SWIGTYPE_p_SoMFUShort swig_types[425]
#define SWIGTYPE_p_SoMFVec2b swig_types[426]
#define SWIGTYPE_p_SoMFVec2d swig_types[427]
#define SWIGTYPE_p_SoMFVec2f swig_types[428]
#define SWIGTYPE_p_SoMFVec2i32 swig_types[429]
#define SWIGTYPE_p_SoMFVec2s swig_types[430]
#define SWIGTYPE_p_SoMFVec3b swig_types[431]
#define SWIGTYPE_p_SoMFVec3d swig_types[432]
#define SWIGTYPE_p_SoMFVec3f swig_types[433]
#define SWIGTYPE_p_SoMFVec3i32 swig_types[434]
#define SWIGTYPE_p_SoMFVec3s swig_types[435]
#define SWIGTYPE_p_SoMFVec4b swig_types[436]
#define SWIGTYPE_p_SoMFVec4d swig_types[437]
#define SWIGTYPE_p_SoMFVec4f swig_types[438]
#define SWIGTYPE_p_SoMFVec4i32 swig_types[439]
#define SWIGTYPE_p_SoMFVec4s swig_types[440]
#define SWIGTYPE_p_SoMFVec4ub swig_types[441]
#define SWIGTYPE_p_SoMFVec4ui32 swig_types[442]
#define SWIGTYPE_p_SoMFVec4us swig_types[443]
#define SWIGTYPE_p_SoMField swig_types[444]
#define SWIGTYPE_p_SoMarkerSet swig_types[445]
#define SWIGTYPE_p_SoMaterial swig_types[446]
#define SWIGTYPE_p_SoMaterialBinding swig_types[447]
#define SWIGTYPE_p_SoMaterialBindingElement swig_types[448]
#define SWIGTYPE_p_SoMaterialBundle swig_types[449]
#define SWIGTYPE_p_SoMatrixTransform swig_types[450]
#define SWIGTYPE_p_SoMemoryError swig_types[451]
#define SWIGTYPE_p_SoModelMatrixElement swig_types[452]
#define SWIGTYPE_p_SoMotion3Event swig_types[453]
#define SWIGTYPE_p_SoMouseButtonEvent swig_types[454]
#define SWIGTYPE_p_SoMultiTextureCoordinateElement swig_types[455]
#define SWIGTYPE_p_SoMultiTextureEnabledElement swig_types[456]
#define SWIGTYPE_p_SoMultiTextureEnabledElement__Mode swig_types[457]
#define SWIGTYPE_p_SoMultiTextureImageElement swig_types[458]
#define SWIGTYPE_p_SoMultiTextureImageElement__Model swig_types[459]
#define SWIGTYPE_p_SoMultiTextureImageElement__Wrap swig_types[460]
#define SWIGTYPE_p_SoMultiTextureMatrixElement swig_types[461]
#define SWIGTYPE_p_SoMultipleCopy swig_types[462]
#define SWIGTYPE_p_SoNode swig_types[463]
#define SWIGTYPE_p_SoNodeEngine swig_types[464]
#define SWIGTYPE_p_SoNodeKit swig_types[465]
#define SWIGTYPE_p_SoNodeKitDetail swig_types[466]
#define SWIGTYPE_p_SoNodeKitListPart swig_types[467]
#define SWIGTYPE_p_SoNodeKitPath swig_types[468]
#define SWIGTYPE_p_SoNodeList swig_types[469]
#define SWIGTYPE_p_SoNodeSensor swig_types[470]
#define SWIGTYPE_p_SoNodekitCatalog swig_types[471]
#define SWIGTYPE_p_SoNonIndexedShape swig_types[472]
#define SWIGTYPE_p_SoNormal swig_types[473]
#define SWIGTYPE_p_SoNormalBinding swig_types[474]
#define SWIGTYPE_p_SoNormalBindingElement swig_types[475]
#define SWIGTYPE_p_SoNormalBundle swig_types[476]
#define SWIGTYPE_p_SoNormalCache swig_types[477]
#define SWIGTYPE_p_SoNormalElement swig_types[478]
#define SWIGTYPE_p_SoNormalGenerator swig_types[479]
#define SWIGTYPE_p_SoNotList swig_types[480]
#define SWIGTYPE_p_SoNotRec swig_types[481]
#define SWIGTYPE_p_SoNurbsCurve swig_types[482]
#define SWIGTYPE_p_SoNurbsProfile swig_types[483]
#define SWIGTYPE_p_SoNurbsSurface swig_types[484]
#define SWIGTYPE_p_SoOffscreenRenderer swig_types[485]
#define SWIGTYPE_p_SoOnOff swig_types[486]
#define SWIGTYPE_p_SoOneShot swig_types[487]
#define SWIGTYPE_p_SoOneShotSensor swig_types[488]
#define SWIGTYPE_p_SoOrthographicCamera swig_types[489]
#define SWIGTYPE_p_SoOutput swig_types[490]
#define SWIGTYPE_p_SoOverrideElement swig_types[491]
#define SWIGTYPE_p_SoPSVectorOutput swig_types[492]
#define SWIGTYPE_p_SoPackedColor swig_types[493]
#define SWIGTYPE_p_SoPath swig_types[494]
#define SWIGTYPE_p_SoPathList swig_types[495]
#define SWIGTYPE_p_SoPathSensor swig_types[496]
#define SWIGTYPE_p_SoPathSwitch swig_types[497]
#define SWIGTYPE_p_SoPendulum swig_types[498]
#define SWIGTYPE_p_SoPerspectiveCamera swig_types[499]
#define SWIGTYPE_p_SoPickAction swig_types[500]
#define SWIGTYPE_p_SoPickRayElement swig_types[501]
#define SWIGTYPE_p_SoPickStyle swig_types[502]
#define SWIGTYPE_p_SoPickStyleElement swig_types[503]
#define SWIGTYPE_p_SoPickedPoint swig_types[504]
#define SWIGTYPE_p_SoPickedPointList swig_types[505]
#define SWIGTYPE_p_SoPointDetail swig_types[506]
#define SWIGTYPE_p_SoPointLight swig_types[507]
#define SWIGTYPE_p_SoPointLightDragger swig_types[508]
#define SWIGTYPE_p_SoPointLightManip swig_types[509]
#define SWIGTYPE_p_SoPointSet swig_types[510]
#define SWIGTYPE_p_SoPointSizeElement swig_types[511]
#define SWIGTYPE_p_SoPolygonOffset swig_types[512]
#define SWIGTYPE_p_SoPolygonOffsetElement swig_types[513]
#define SWIGTYPE_p_SoPolygonOffsetElement__Style swig_types[514]
#define SWIGTYPE_p_SoPrimitiveVertex swig_types[515]
#define SWIGTYPE_p_SoProfile swig_types[516]
#define SWIGTYPE_p_SoProfileCoordinate2 swig_types[517]
#define SWIGTYPE_p_SoProfileCoordinate3 swig_types[518]
#define SWIGTYPE_p_SoProfileCoordinateElement swig_types[519]
#define SWIGTYPE_p_SoProfileElement swig_types[520]
#define SWIGTYPE_p_SoProjectionMatrixElement swig_types[521]
#define SWIGTYPE_p_SoProto swig_types[522]
#define SWIGTYPE_p_SoProtoInstance swig_types[523]
#define SWIGTYPE_p_SoQuadMesh swig_types[524]
#define SWIGTYPE_p_SoRayPickAction swig_types[525]
#define SWIGTYPE_p_SoReadError swig_types[526]
#define SWIGTYPE_p_SoRenderManager swig_types[527]
#define SWIGTYPE_p_SoRenderManager__Superimposition swig_types[528]
#define SWIGTYPE_p_SoReorganizeAction swig_types[529]
#define SWIGTYPE_p_SoReplacedElement swig_types[530]
#define SWIGTYPE_p_SoResetTransform swig_types[531]
#define SWIGTYPE_p_SoReversePerspectiveCamera swig_types[532]
#define SWIGTYPE_p_SoRotateCylindricalDragger swig_types[533]
#define SWIGTYPE_p_SoRotateDiscDragger swig_types[534]
#define SWIGTYPE_p_SoRotateSphericalDragger swig_types[535]
#define SWIGTYPE_p_SoRotation swig_types[536]
#define SWIGTYPE_p_SoRotationXYZ swig_types[537]
#define SWIGTYPE_p_SoRotor swig_types[538]
#define SWIGTYPE_p_SoSFBitMask swig_types[539]
#define SWIGTYPE_p_SoSFBool swig_types[540]
#define SWIGTYPE_p_SoSFBox2d swig_types[541]
#define SWIGTYPE_p_SoSFBox2f swig_types[542]
#define SWIGTYPE_p_SoSFBox2i32 swig_types[543]
#define SWIGTYPE_p_SoSFBox2s swig_types[544]
#define SWIGTYPE_p_SoSFBox3d swig_types[545]
#define SWIGTYPE_p_SoSFBox3f swig_types[546]
#define SWIGTYPE_p_SoSFBox3i32 swig_types[547]
#define SWIGTYPE_p_SoSFBox3s swig_types[548]
#define SWIGTYPE_p_SoSFColor swig_types[549]
#define SWIGTYPE_p_SoSFColorRGBA swig_types[550]
#define SWIGTYPE_p_SoSFDouble swig_types[551]
#define SWIGTYPE_p_SoSFEngine swig_types[552]
#define SWIGTYPE_p_SoSFEnum swig_types[553]
#define SWIGTYPE_p_SoSFFloat swig_types[554]
#define SWIGTYPE_p_SoSFImage swig_types[555]
#define SWIGTYPE_p_SoSFImage3 swig_types[556]
#define SWIGTYPE_p_SoSFInt32 swig_types[557]
#define SWIGTYPE_p_SoSFMatrix swig_types[558]
#define SWIGTYPE_p_SoSFName swig_types[559]
#define SWIGTYPE_p_SoSFNode swig_types[560]
#define SWIGTYPE_p_SoSFPath swig_types[561]
#define SWIGTYPE_p_SoSFPlane swig_types[562]
#define SWIGTYPE_p_SoSFRotation swig_types[563]
#define SWIGTYPE_p_SoSFShort swig_types[564]
#define SWIGTYPE_p_SoSFString swig_types[565]
#define SWIGTYPE_p_SoSFTime swig_types[566]
#define SWIGTYPE_p_SoSFTrigger swig_types[567]
#define SWIGTYPE_p_SoSFUInt32 swig_types[568]
#define SWIGTYPE_p_SoSFUShort swig_types[569]
#define SWIGTYPE_p_SoSFVec2b swig_types[570]
#define SWIGTYPE_p_SoSFVec2d swig_types[571]
#define SWIGTYPE_p_SoSFVec2f swig_types[572]
#define SWIGTYPE_p_SoSFVec2i32 swig_types[573]
#define SWIGTYPE_p_SoSFVec2s swig_types[574]
#define SWIGTYPE_p_SoSFVec3b swig_types[575]
#define SWIGTYPE_p_SoSFVec3d swig_types[576]
#define SWIGTYPE_p_SoSFVec3f swig_types[577]
#define SWIGTYPE_p_SoSFVec3i32 swig_types[578]
#define SWIGTYPE_p_SoSFVec3s swig_types[579]
#define SWIGTYPE_p_SoSFVec4b swig_types[580]
#define SWIGTYPE_p_SoSFVec4d swig_types[581]
#define SWIGTYPE_p_SoSFVec4f swig_types[582]
#define SWIGTYPE_p_SoSFVec4i32 swig_types[583]
#define SWIGTYPE_p_SoSFVec4s swig_types[584]
#define SWIGTYPE_p_SoSFVec4ub swig_types[585]
#define SWIGTYPE_p_SoSFVec4ui32 swig_types[586]
#define SWIGTYPE_p_SoSFVec4us swig_types[587]
#define SWIGTYPE_p_SoSField swig_types[588]
#define SWIGTYPE_p_SoScXMLDollyTarget swig_types[589]
#define SWIGTYPE_p_SoScXMLEvent swig_types[590]
#define SWIGTYPE_p_SoScXMLFlightControlTarget swig_types[591]
#define SWIGTYPE_p_SoScXMLMiscTarget swig_types[592]
#define SWIGTYPE_p_SoScXMLMotionTarget swig_types[593]
#define SWIGTYPE_p_SoScXMLNavigation swig_types[594]
#define SWIGTYPE_p_SoScXMLNavigationTarget swig_types[595]
#define SWIGTYPE_p_SoScXMLPanTarget swig_types[596]
#define SWIGTYPE_p_SoScXMLRotateTarget swig_types[597]
#define SWIGTYPE_p_SoScXMLSeekTarget swig_types[598]
#define SWIGTYPE_p_SoScXMLSpinTarget swig_types[599]
#define SWIGTYPE_p_SoScXMLStateMachine swig_types[600]
#define SWIGTYPE_p_SoScXMLZoomTarget swig_types[601]
#define SWIGTYPE_p_SoScale swig_types[602]
#define SWIGTYPE_p_SoScale1Dragger swig_types[603]
#define SWIGTYPE_p_SoScale2Dragger swig_types[604]
#define SWIGTYPE_p_SoScale2UniformDragger swig_types[605]
#define SWIGTYPE_p_SoScaleUniformDragger swig_types[606]
#define SWIGTYPE_p_SoSceneKit swig_types[607]
#define SWIGTYPE_p_SoSceneManager swig_types[608]
#define SWIGTYPE_p_SoSceneTexture2 swig_types[609]
#define SWIGTYPE_p_SoSceneTextureCubeMap swig_types[610]
#define SWIGTYPE_p_SoSearchAction swig_types[611]
#define SWIGTYPE_p_SoSelectOne swig_types[612]
#define SWIGTYPE_p_SoSelection swig_types[613]
#define SWIGTYPE_p_SoSensor swig_types[614]
#define SWIGTYPE_p_SoSensorManager swig_types[615]
#define SWIGTYPE_p_SoSeparator swig_types[616]
#define SWIGTYPE_p_SoSeparatorKit swig_types[617]
#define SWIGTYPE_p_SoShaderObject swig_types[618]
#define SWIGTYPE_p_SoShaderParameter swig_types[619]
#define SWIGTYPE_p_SoShaderParameter1f swig_types[620]
#define SWIGTYPE_p_SoShaderParameter1i swig_types[621]
#define SWIGTYPE_p_SoShaderParameter2f swig_types[622]
#define SWIGTYPE_p_SoShaderParameter2i swig_types[623]
#define SWIGTYPE_p_SoShaderParameter3f swig_types[624]
#define SWIGTYPE_p_SoShaderParameter3i swig_types[625]
#define SWIGTYPE_p_SoShaderParameter4f swig_types[626]
#define SWIGTYPE_p_SoShaderParameter4i swig_types[627]
#define SWIGTYPE_p_SoShaderParameterArray1f swig_types[628]
#define SWIGTYPE_p_SoShaderParameterArray1i swig_types[629]
#define SWIGTYPE_p_SoShaderParameterArray2f swig_types[630]
#define SWIGTYPE_p_SoShaderParameterArray2i swig_types[631]
#define SWIGTYPE_p_SoShaderParameterArray3f swig_types[632]
#define SWIGTYPE_p_SoShaderParameterArray3i swig_types[633]
#define SWIGTYPE_p_SoShaderParameterArray4f swig_types[634]
#define SWIGTYPE_p_SoShaderParameterArray4i swig_types[635]
#define SWIGTYPE_p_SoShaderParameterMatrix swig_types[636]
#define SWIGTYPE_p_SoShaderParameterMatrixArray swig_types[637]
#define SWIGTYPE_p_SoShaderProgram swig_types[638]
#define SWIGTYPE_p_SoShaderStateMatrixParameter swig_types[639]
#define SWIGTYPE_p_SoShape swig_types[640]
#define SWIGTYPE_p_SoShapeHints swig_types[641]
#define SWIGTYPE_p_SoShapeHintsElement swig_types[642]
#define SWIGTYPE_p_SoShapeHintsElement__FaceType swig_types[643]
#define SWIGTYPE_p_SoShapeHintsElement__ShapeType swig_types[644]
#define SWIGTYPE_p_SoShapeHintsElement__VertexOrdering swig_types[645]
#define SWIGTYPE_p_SoShapeKit swig_types[646]
#define SWIGTYPE_p_SoShapeStyleElement swig_types[647]
#define SWIGTYPE_p_SoShininessElement swig_types[648]
#define SWIGTYPE_p_SoShuttle swig_types[649]
#define SWIGTYPE_p_SoSimplifier swig_types[650]
#define SWIGTYPE_p_SoSimplifyAction swig_types[651]
#define SWIGTYPE_p_SoSoundElement swig_types[652]
#define SWIGTYPE_p_SoSpaceballButtonEvent swig_types[653]
#define SWIGTYPE_p_SoSpecularColorElement swig_types[654]
#define SWIGTYPE_p_SoSphere swig_types[655]
#define SWIGTYPE_p_SoSpotLight swig_types[656]
#define SWIGTYPE_p_SoSpotLightDragger swig_types[657]
#define SWIGTYPE_p_SoSpotLightManip swig_types[658]
#define SWIGTYPE_p_SoState swig_types[659]
#define SWIGTYPE_p_SoSurroundScale swig_types[660]
#define SWIGTYPE_p_SoSwitch swig_types[661]
#define SWIGTYPE_p_SoSwitchElement swig_types[662]
#define SWIGTYPE_p_SoTabBoxDragger swig_types[663]
#define SWIGTYPE_p_SoTabBoxManip swig_types[664]
#define SWIGTYPE_p_SoTabPlaneDragger swig_types[665]
#define SWIGTYPE_p_SoTempPath swig_types[666]
#define SWIGTYPE_p_SoText2 swig_types[667]
#define SWIGTYPE_p_SoText3 swig_types[668]
#define SWIGTYPE_p_SoTextDetail swig_types[669]
#define SWIGTYPE_p_SoTextOutlineEnabledElement swig_types[670]
#define SWIGTYPE_p_SoTexture swig_types[671]
#define SWIGTYPE_p_SoTexture2 swig_types[672]
#define SWIGTYPE_p_SoTexture2Convert swig_types[673]
#define SWIGTYPE_p_SoTexture2Transform swig_types[674]
#define SWIGTYPE_p_SoTexture3 swig_types[675]
#define SWIGTYPE_p_SoTexture3Transform swig_types[676]
#define SWIGTYPE_p_SoTextureCombine swig_types[677]
#define SWIGTYPE_p_SoTextureCombineElement swig_types[678]
#define SWIGTYPE_p_SoTextureCombineElement__Operand swig_types[679]
#define SWIGTYPE_p_SoTextureCombineElement__Operation swig_types[680]
#define SWIGTYPE_p_SoTextureCombineElement__Source swig_types[681]
#define SWIGTYPE_p_SoTextureCoordinate2 swig_types[682]
#define SWIGTYPE_p_SoTextureCoordinate3 swig_types[683]
#define SWIGTYPE_p_SoTextureCoordinateBinding swig_types[684]
#define SWIGTYPE_p_SoTextureCoordinateBindingElement swig_types[685]
#define SWIGTYPE_p_SoTextureCoordinateBundle swig_types[686]
#define SWIGTYPE_p_SoTextureCoordinateCache swig_types[687]
#define SWIGTYPE_p_SoTextureCoordinateCube swig_types[688]
#define SWIGTYPE_p_SoTextureCoordinateCylinder swig_types[689]
#define SWIGTYPE_p_SoTextureCoordinateDefault swig_types[690]
#define SWIGTYPE_p_SoTextureCoordinateEnvironment swig_types[691]
#define SWIGTYPE_p_SoTextureCoordinateFunction swig_types[692]
#define SWIGTYPE_p_SoTextureCoordinateNormalMap swig_types[693]
#define SWIGTYPE_p_SoTextureCoordinateObject swig_types[694]
#define SWIGTYPE_p_SoTextureCoordinatePlane swig_types[695]
#define SWIGTYPE_p_SoTextureCoordinateReflectionMap swig_types[696]
#define SWIGTYPE_p_SoTextureCoordinateSphere swig_types[697]
#define SWIGTYPE_p_SoTextureCubeMap swig_types[698]
#define SWIGTYPE_p_SoTextureMatrixTransform swig_types[699]
#define SWIGTYPE_p_SoTextureOverrideElement swig_types[700]
#define SWIGTYPE_p_SoTextureQualityElement swig_types[701]
#define SWIGTYPE_p_SoTextureScalePolicy swig_types[702]
#define SWIGTYPE_p_SoTextureUnit swig_types[703]
#define SWIGTYPE_p_SoTextureUnitElement swig_types[704]
#define SWIGTYPE_p_SoTimeCounter swig_types[705]
#define SWIGTYPE_p_SoTimerQueueSensor swig_types[706]
#define SWIGTYPE_p_SoTimerSensor swig_types[707]
#define SWIGTYPE_p_SoToVRML2Action swig_types[708]
#define SWIGTYPE_p_SoToVRMLAction swig_types[709]
#define SWIGTYPE_p_SoTrackballDragger swig_types[710]
#define SWIGTYPE_p_SoTrackballManip swig_types[711]
#define SWIGTYPE_p_SoTranReceiver swig_types[712]
#define SWIGTYPE_p_SoTranSender swig_types[713]
#define SWIGTYPE_p_SoTransform swig_types[714]
#define SWIGTYPE_p_SoTransformBoxDragger swig_types[715]
#define SWIGTYPE_p_SoTransformBoxManip swig_types[716]
#define SWIGTYPE_p_SoTransformManip swig_types[717]
#define SWIGTYPE_p_SoTransformSeparator swig_types[718]
#define SWIGTYPE_p_SoTransformVec3f swig_types[719]
#define SWIGTYPE_p_SoTransformation swig_types[720]
#define SWIGTYPE_p_SoTransformerDragger swig_types[721]
#define SWIGTYPE_p_SoTransformerManip swig_types[722]
#define SWIGTYPE_p_SoTranslate1Dragger swig_types[723]
#define SWIGTYPE_p_SoTranslate2Dragger swig_types[724]
#define SWIGTYPE_p_SoTranslation swig_types[725]
#define SWIGTYPE_p_SoTransparencyElement swig_types[726]
#define SWIGTYPE_p_SoTransparencyType swig_types[727]
#define SWIGTYPE_p_SoTriangleStripSet swig_types[728]
#define SWIGTYPE_p_SoTriggerAny swig_types[729]
#define SWIGTYPE_p_SoType swig_types[730]
#define SWIGTYPE_p_SoTypeList swig_types[731]
#define SWIGTYPE_p_SoUniformShaderParameter swig_types[732]
#define SWIGTYPE_p_SoUnits swig_types[733]
#define SWIGTYPE_p_SoUnitsElement swig_types[734]
#define SWIGTYPE_p_SoVBO swig_types[735]
#define SWIGTYPE_p_SoVRMLAnchor swig_types[736]
#define SWIGTYPE_p_SoVRMLAppearance swig_types[737]
#define SWIGTYPE_p_SoVRMLAudioClip swig_types[738]
#define SWIGTYPE_p_SoVRMLBackground swig_types[739]
#define SWIGTYPE_p_SoVRMLBillboard swig_types[740]
#define SWIGTYPE_p_SoVRMLBox swig_types[741]
#define SWIGTYPE_p_SoVRMLCollision swig_types[742]
#define SWIGTYPE_p_SoVRMLColor swig_types[743]
#define SWIGTYPE_p_SoVRMLColorInterpolator swig_types[744]
#define SWIGTYPE_p_SoVRMLCone swig_types[745]
#define SWIGTYPE_p_SoVRMLCoordinate swig_types[746]
#define SWIGTYPE_p_SoVRMLCoordinateInterpolator swig_types[747]
#define SWIGTYPE_p_SoVRMLCylinder swig_types[748]
#define SWIGTYPE_p_SoVRMLCylinderSensor swig_types[749]
#define SWIGTYPE_p_SoVRMLDirectionalLight swig_types[750]
#define SWIGTYPE_p_SoVRMLDragSensor swig_types[751]
#define SWIGTYPE_p_SoVRMLElevationGrid swig_types[752]
#define SWIGTYPE_p_SoVRMLExtrusion swig_types[753]
#define SWIGTYPE_p_SoVRMLFog swig_types[754]
#define SWIGTYPE_p_SoVRMLFontStyle swig_types[755]
#define SWIGTYPE_p_SoVRMLGeometry swig_types[756]
#define SWIGTYPE_p_SoVRMLGroup swig_types[757]
#define SWIGTYPE_p_SoVRMLImageTexture swig_types[758]
#define SWIGTYPE_p_SoVRMLIndexedFaceSet swig_types[759]
#define SWIGTYPE_p_SoVRMLIndexedLine swig_types[760]
#define SWIGTYPE_p_SoVRMLIndexedLineSet swig_types[761]
#define SWIGTYPE_p_SoVRMLIndexedShape swig_types[762]
#define SWIGTYPE_p_SoVRMLInline swig_types[763]
#define SWIGTYPE_p_SoVRMLInterpolator swig_types[764]
#define SWIGTYPE_p_SoVRMLLOD swig_types[765]
#define SWIGTYPE_p_SoVRMLLight swig_types[766]
#define SWIGTYPE_p_SoVRMLMaterial swig_types[767]
#define SWIGTYPE_p_SoVRMLMovieTexture swig_types[768]
#define SWIGTYPE_p_SoVRMLNavigationInfo swig_types[769]
#define SWIGTYPE_p_SoVRMLNormal swig_types[770]
#define SWIGTYPE_p_SoVRMLNormalInterpolator swig_types[771]
#define SWIGTYPE_p_SoVRMLOrientationInterpolator swig_types[772]
#define SWIGTYPE_p_SoVRMLParent swig_types[773]
#define SWIGTYPE_p_SoVRMLPixelTexture swig_types[774]
#define SWIGTYPE_p_SoVRMLPlaneSensor swig_types[775]
#define SWIGTYPE_p_SoVRMLPointLight swig_types[776]
#define SWIGTYPE_p_SoVRMLPointSet swig_types[777]
#define SWIGTYPE_p_SoVRMLPositionInterpolator swig_types[778]
#define SWIGTYPE_p_SoVRMLProximitySensor swig_types[779]
#define SWIGTYPE_p_SoVRMLScalarInterpolator swig_types[780]
#define SWIGTYPE_p_SoVRMLScript swig_types[781]
#define SWIGTYPE_p_SoVRMLSensor swig_types[782]
#define SWIGTYPE_p_SoVRMLShape swig_types[783]
#define SWIGTYPE_p_SoVRMLSound swig_types[784]
#define SWIGTYPE_p_SoVRMLSphere swig_types[785]
#define SWIGTYPE_p_SoVRMLSphereSensor swig_types[786]
#define SWIGTYPE_p_SoVRMLSpotLight swig_types[787]
#define SWIGTYPE_p_SoVRMLSwitch swig_types[788]
#define SWIGTYPE_p_SoVRMLText swig_types[789]
#define SWIGTYPE_p_SoVRMLTexture swig_types[790]
#define SWIGTYPE_p_SoVRMLTextureCoordinate swig_types[791]
#define SWIGTYPE_p_SoVRMLTextureTransform swig_types[792]
#define SWIGTYPE_p_SoVRMLTimeSensor swig_types[793]
#define SWIGTYPE_p_SoVRMLTouchSensor swig_types[794]
#define SWIGTYPE_p_SoVRMLTransform swig_types[795]
#define SWIGTYPE_p_SoVRMLVertexLine swig_types[796]
#define SWIGTYPE_p_SoVRMLVertexPoint swig_types[797]
#define SWIGTYPE_p_SoVRMLVertexShape swig_types[798]
#define SWIGTYPE_p_SoVRMLViewpoint swig_types[799]
#define SWIGTYPE_p_SoVRMLVisibilitySensor swig_types[800]
#define SWIGTYPE_p_SoVRMLWorldInfo swig_types[801]
#define SWIGTYPE_p_SoVectorOutput swig_types[802]
#define SWIGTYPE_p_SoVectorizeAction swig_types[803]
#define SWIGTYPE_p_SoVectorizePSAction swig_types[804]
#define SWIGTYPE_p_SoVertexAttribute swig_types[805]
#define SWIGTYPE_p_SoVertexAttributeBinding swig_types[806]
#define SWIGTYPE_p_SoVertexAttributeBindingElement swig_types[807]
#define SWIGTYPE_p_SoVertexAttributeData swig_types[808]
#define SWIGTYPE_p_SoVertexAttributeElement swig_types[809]
#define SWIGTYPE_p_SoVertexProperty swig_types[810]
#define SWIGTYPE_p_SoVertexShader swig_types[811]
#define SWIGTYPE_p_SoVertexShape swig_types[812]
#define SWIGTYPE_p_SoViewVolumeElement swig_types[813]
#define SWIGTYPE_p_SoViewingMatrixElement swig_types[814]
#define SWIGTYPE_p_SoViewportRegionElement swig_types[815]
#define SWIGTYPE_p_SoWWWAnchor swig_types[816]
#define SWIGTYPE_p_SoWWWInline swig_types[817]
#define SWIGTYPE_p_SoWindowElement swig_types[818]
#define SWIGTYPE_p_SoWrapperKit swig_types[819]
#define SWIGTYPE_p_SoWriteAction swig_types[820]
#define SWIGTYPE_p_a_2__double swig_types[821]
#define SWIGTYPE_p_a_2__doublep swig_types[822]
#define SWIGTYPE_p_a_2__int swig_types[823]
#define SWIGTYPE_p_a_2__intp swig_types[824]
#define SWIGTYPE_p_a_2__short swig_types[825]
#define SWIGTYPE_p_a_2__signed_char swig_types[826]
#define SWIGTYPE_p_a_3__int swig_types[827]
#define SWIGTYPE_p_a_3__intp swig_types[828]
#define SWIGTYPE_p_a_3__short swig_types[829]
#define SWIGTYPE_p_a_3__signed_char swig_types[830]
#define SWIGTYPE_p_a_4__a_4__double swig_types[831]
#define SWIGTYPE_p_a_4__a_4__doublep swig_types[832]
#define SWIGTYPE_p_a_4__a_4__float swig_types[833]
#define SWIGTYPE_p_a_4__a_4__floatp swig_types[834]
#define SWIGTYPE_p_a_4__double swig_types[835]
#define SWIGTYPE_p_a_4__doublep swig_types[836]
#define SWIGTYPE_p_a_4__float swig_types[837]
#define SWIGTYPE_p_a_4__floatp swig_types[838]
#define SWIGTYPE_p_a_4__int swig_types[839]
#define SWIGTYPE_p_a_4__intp swig_types[840]
#define SWIGTYPE_p_a_4__short swig_types[841]
#define SWIGTYPE_p_a_4__signed_char swig_types[842]
#define SWIGTYPE_p_a_4__unsigned_char swig_types[843]
#define SWIGTYPE_p_a_4__unsigned_int swig_types[844]
#define SWIGTYPE_p_a_4__unsigned_short swig_types[845]
#define SWIGTYPE_p_cc_glglue swig_types[846]
#define SWIGTYPE_p_cc_storage_f swig_types[847]
#define SWIGTYPE_p_cc_xml_doc swig_types[848]
#define SWIGTYPE_p_cc_xml_elt swig_types[849]
#define SWIGTYPE_p_char swig_types[850]
#define SWIGTYPE_p_charp swig_types[851]
#define SWIGTYPE_p_close_func swig_types[852]
#define SWIGTYPE_p_double swig_types[853]
#define SWIGTYPE_p_doublep swig_types[854]
#define SWIGTYPE_p_f_char__char swig_types[855]
#define SWIGTYPE_p_f_char__charp swig_types[856]
#define SWIGTYPE_p_f_float_p_void__int swig_types[857]
#define SWIGTYPE_p_f_float_p_void__intp swig_types[858]
#define SWIGTYPE_p_f_p_SoAction_p_SoNode__void swig_types[859]
#define SWIGTYPE_p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto swig_types[860]
#define SWIGTYPE_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int swig_types[861]
#define SWIGTYPE_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp swig_types[862]
#define SWIGTYPE_p_f_p_q_const__SoError_p_void__void swig_types[863]
#define SWIGTYPE_p_f_p_void__SoGLRenderAction__AbortCode swig_types[864]
#define SWIGTYPE_p_f_p_void__float swig_types[865]
#define SWIGTYPE_p_f_p_void__floatp swig_types[866]
#define SWIGTYPE_p_f_p_void__int swig_types[867]
#define SWIGTYPE_p_f_p_void__intp swig_types[868]
#define SWIGTYPE_p_f_p_void__p_void swig_types[869]
#define SWIGTYPE_p_f_p_void__void swig_types[870]
#define SWIGTYPE_p_f_p_void_int__void swig_types[871]
#define SWIGTYPE_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int swig_types[872]
#define SWIGTYPE_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp swig_types[873]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void swig_types[874]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void swig_types[875]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void swig_types[876]
#define SWIGTYPE_p_f_p_void_p_SoAction__void swig_types[877]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response swig_types[878]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int swig_types[879]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp swig_types[880]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void swig_types[881]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int swig_types[882]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp swig_types[883]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void swig_types[884]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int swig_types[885]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp swig_types[886]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void swig_types[887]
#define SWIGTYPE_p_f_p_void_p_SoDragger__void swig_types[888]
#define SWIGTYPE_p_f_p_void_p_SoEventCallback__void swig_types[889]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float swig_types[890]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__floatp swig_types[891]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void swig_types[892]
#define SWIGTYPE_p_f_p_void_p_SoInput__void swig_types[893]
#define SWIGTYPE_p_f_p_void_p_SoPath__void swig_types[894]
#define SWIGTYPE_p_f_p_void_p_SoRenderManager__void swig_types[895]
#define SWIGTYPE_p_f_p_void_p_SoSceneManager__void swig_types[896]
#define SWIGTYPE_p_f_p_void_p_SoSelection__void swig_types[897]
#define SWIGTYPE_p_f_p_void_p_SoSensor__void swig_types[898]
#define SWIGTYPE_p_f_p_void_p_SoState_q_const__int__void swig_types[899]
#define SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__int swig_types[900]
#define SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__intp swig_types[901]
#define SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__long swig_types[902]
#define SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__longp swig_types[903]
#define SWIGTYPE_p_f_p_void_p_SoVRMLScript__void swig_types[904]
#define SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp swig_types[905]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response swig_types[906]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoFullPath swig_types[907]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath swig_types[908]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath swig_types[909]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoTempPath swig_types[910]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int swig_types[911]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp swig_types[912]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath swig_types[913]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath swig_types[914]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath swig_types[915]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath swig_types[916]
#define SWIGTYPE_p_f_p_void_p_void__int swig_types[917]
#define SWIGTYPE_p_f_p_void_p_void__intp swig_types[918]
#define SWIGTYPE_p_f_p_void_p_void__void swig_types[919]
#define SWIGTYPE_p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t swig_types[920]
#define SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void swig_types[921]
#define SWIGTYPE_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f swig_types[922]
#define SWIGTYPE_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f swig_types[923]
#define SWIGTYPE_p_f_p_void_size_t__p_void swig_types[924]
#define SWIGTYPE_p_f_p_void_unsigned_int__void swig_types[925]
#define SWIGTYPE_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int swig_types[926]
#define SWIGTYPE_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp swig_types[927]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbBox3f__int swig_types[928]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbBox3f__intp swig_types[929]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbSphere__int swig_types[930]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbSphere__intp swig_types[931]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbVec3f__int swig_types[932]
#define SWIGTYPE_p_f_q_const__p_void_r_q_const__SbVec3f__intp swig_types[933]
#define SWIGTYPE_p_f_q_const__unsigned_int__unsigned_int swig_types[934]
#define SWIGTYPE_p_f_r_q_const__SbName_float_int_p_void__int swig_types[935]
#define SWIGTYPE_p_f_r_q_const__SbName_float_int_p_void__intp swig_types[936]
#define SWIGTYPE_p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void swig_types[937]
#define SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int swig_types[938]
#define SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__intp swig_types[939]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void swig_types[940]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int swig_types[941]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp swig_types[942]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void swig_types[943]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void swig_types[944]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWInline__void swig_types[945]
#define SWIGTYPE_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void swig_types[946]
#define SWIGTYPE_p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void swig_types[947]
#define SWIGTYPE_p_f_unsigned_int_p_void__void swig_types[948]
#define SWIGTYPE_p_f_unsigned_int_p_void_p_void__void swig_types[949]
#define SWIGTYPE_p_f_void__p_void swig_types[950]
#define SWIGTYPE_p_float swig_types[951]
#define SWIGTYPE_p_floatp swig_types[952]
#define SWIGTYPE_p_int swig_types[953]
#define SWIGTYPE_p_intp swig_types[954]
#define SWIGTYPE_p_long swig_types[955]
#define SWIGTYPE_p_long_long swig_types[956]
#define SWIGTYPE_p_longp swig_types[957]
#define SWIGTYPE_p_open_func swig_types[958]
#define SWIGTYPE_p_p_SbName swig_types[959]
#define SWIGTYPE_p_p_SbString swig_types[960]
#define SWIGTYPE_p_p_SbVec2f swig_types[961]
#define SWIGTYPE_p_p_ScXMLAddOpExprDataObj swig_types[962]
#define SWIGTYPE_p_p_ScXMLAndOpExprDataObj swig_types[963]
#define SWIGTYPE_p_p_ScXMLAppendOpExprDataObj swig_types[964]
#define SWIGTYPE_p_p_ScXMLBoolDataObj swig_types[965]
#define SWIGTYPE_p_p_ScXMLCoinAddOpExprDataObj swig_types[966]
#define SWIGTYPE_p_p_ScXMLCoinDivideOpExprDataObj swig_types[967]
#define SWIGTYPE_p_p_ScXMLCoinEqualsOpExprDataObj swig_types[968]
#define SWIGTYPE_p_p_ScXMLCoinLengthFuncExprDataObj swig_types[969]
#define SWIGTYPE_p_p_ScXMLCoinMultiplyOpExprDataObj swig_types[970]
#define SWIGTYPE_p_p_ScXMLCoinSubtractOpExprDataObj swig_types[971]
#define SWIGTYPE_p_p_ScXMLConstantDataObj swig_types[972]
#define SWIGTYPE_p_p_ScXMLDataObj swig_types[973]
#define SWIGTYPE_p_p_ScXMLDivideOpExprDataObj swig_types[974]
#define SWIGTYPE_p_p_ScXMLEqualsOpExprDataObj swig_types[975]
#define SWIGTYPE_p_p_ScXMLExprDataObj swig_types[976]
#define SWIGTYPE_p_p_ScXMLInExprDataObj swig_types[977]
#define SWIGTYPE_p_p_ScXMLMinimumExprDataObj swig_types[978]
#define SWIGTYPE_p_p_ScXMLMultiplyOpExprDataObj swig_types[979]
#define SWIGTYPE_p_p_ScXMLNegateOpExprDataObj swig_types[980]
#define SWIGTYPE_p_p_ScXMLNotOpExprDataObj swig_types[981]
#define SWIGTYPE_p_p_ScXMLOrOpExprDataObj swig_types[982]
#define SWIGTYPE_p_p_ScXMLRealDataObj swig_types[983]
#define SWIGTYPE_p_p_ScXMLReferenceDataObj swig_types[984]
#define SWIGTYPE_p_p_ScXMLSbDataObj swig_types[985]
#define SWIGTYPE_p_p_ScXMLStringDataObj swig_types[986]
#define SWIGTYPE_p_p_ScXMLSubtractOpExprDataObj swig_types[987]
#define SWIGTYPE_p_p_ScXMLXMLDataObj swig_types[988]
#define SWIGTYPE_p_p_SoAlphaTest swig_types[989]
#define SWIGTYPE_p_p_SoAnnotation swig_types[990]
#define SWIGTYPE_p_p_SoAntiSquish swig_types[991]
#define SWIGTYPE_p_p_SoAppearanceKit swig_types[992]
#define SWIGTYPE_p_p_SoArray swig_types[993]
#define SWIGTYPE_p_p_SoAsciiText swig_types[994]
#define SWIGTYPE_p_p_SoBase swig_types[995]
#define SWIGTYPE_p_p_SoBaseColor swig_types[996]
#define SWIGTYPE_p_p_SoBaseKit swig_types[997]
#define SWIGTYPE_p_p_SoBlinker swig_types[998]
#define SWIGTYPE_p_p_SoBoolOperation swig_types[999]
#define SWIGTYPE_p_p_SoBoxHighlightRenderAction swig_types[1000]
#define SWIGTYPE_p_p_SoBumpMap swig_types[1001]
#define SWIGTYPE_p_p_SoBumpMapCoordinate swig_types[1002]
#define SWIGTYPE_p_p_SoBumpMapTransform swig_types[1003]
#define SWIGTYPE_p_p_SoCacheHint swig_types[1004]
#define SWIGTYPE_p_p_SoCalculator swig_types[1005]
#define SWIGTYPE_p_p_SoCallback swig_types[1006]
#define SWIGTYPE_p_p_SoCamera swig_types[1007]
#define SWIGTYPE_p_p_SoCameraKit swig_types[1008]
#define SWIGTYPE_p_p_SoCenterballDragger swig_types[1009]
#define SWIGTYPE_p_p_SoCenterballManip swig_types[1010]
#define SWIGTYPE_p_p_SoClipPlane swig_types[1011]
#define SWIGTYPE_p_p_SoClipPlaneManip swig_types[1012]
#define SWIGTYPE_p_p_SoColorIndex swig_types[1013]
#define SWIGTYPE_p_p_SoComplexity swig_types[1014]
#define SWIGTYPE_p_p_SoComposeMatrix swig_types[1015]
#define SWIGTYPE_p_p_SoComposeRotation swig_types[1016]
#define SWIGTYPE_p_p_SoComposeRotationFromTo swig_types[1017]
#define SWIGTYPE_p_p_SoComposeVec2f swig_types[1018]
#define SWIGTYPE_p_p_SoComposeVec3f swig_types[1019]
#define SWIGTYPE_p_p_SoComposeVec4f swig_types[1020]
#define SWIGTYPE_p_p_SoComputeBoundingBox swig_types[1021]
#define SWIGTYPE_p_p_SoConcatenate swig_types[1022]
#define SWIGTYPE_p_p_SoCone swig_types[1023]
#define SWIGTYPE_p_p_SoCoordinate3 swig_types[1024]
#define SWIGTYPE_p_p_SoCoordinate4 swig_types[1025]
#define SWIGTYPE_p_p_SoCounter swig_types[1026]
#define SWIGTYPE_p_p_SoCube swig_types[1027]
#define SWIGTYPE_p_p_SoCylinder swig_types[1028]
#define SWIGTYPE_p_p_SoDecomposeMatrix swig_types[1029]
#define SWIGTYPE_p_p_SoDecomposeRotation swig_types[1030]
#define SWIGTYPE_p_p_SoDecomposeVec2f swig_types[1031]
#define SWIGTYPE_p_p_SoDecomposeVec3f swig_types[1032]
#define SWIGTYPE_p_p_SoDecomposeVec4f swig_types[1033]
#define SWIGTYPE_p_p_SoDepthBuffer swig_types[1034]
#define SWIGTYPE_p_p_SoDirectionalLight swig_types[1035]
#define SWIGTYPE_p_p_SoDirectionalLightDragger swig_types[1036]
#define SWIGTYPE_p_p_SoDirectionalLightManip swig_types[1037]
#define SWIGTYPE_p_p_SoDragPointDragger swig_types[1038]
#define SWIGTYPE_p_p_SoDragger swig_types[1039]
#define SWIGTYPE_p_p_SoDrawStyle swig_types[1040]
#define SWIGTYPE_p_p_SoElapsedTime swig_types[1041]
#define SWIGTYPE_p_p_SoEngine swig_types[1042]
#define SWIGTYPE_p_p_SoEngineOutput swig_types[1043]
#define SWIGTYPE_p_p_SoEnvironment swig_types[1044]
#define SWIGTYPE_p_p_SoEventCallback swig_types[1045]
#define SWIGTYPE_p_p_SoExtSelection swig_types[1046]
#define SWIGTYPE_p_p_SoFaceSet swig_types[1047]
#define SWIGTYPE_p_p_SoField swig_types[1048]
#define SWIGTYPE_p_p_SoFieldContainer swig_types[1049]
#define SWIGTYPE_p_p_SoFieldConverter swig_types[1050]
#define SWIGTYPE_p_p_SoFile swig_types[1051]
#define SWIGTYPE_p_p_SoFont swig_types[1052]
#define SWIGTYPE_p_p_SoFontStyle swig_types[1053]
#define SWIGTYPE_p_p_SoFragmentShader swig_types[1054]
#define SWIGTYPE_p_p_SoFrustumCamera swig_types[1055]
#define SWIGTYPE_p_p_SoFullPath swig_types[1056]
#define SWIGTYPE_p_p_SoGLRenderAction swig_types[1057]
#define SWIGTYPE_p_p_SoGate swig_types[1058]
#define SWIGTYPE_p_p_SoGeoCoordinate swig_types[1059]
#define SWIGTYPE_p_p_SoGeoLocation swig_types[1060]
#define SWIGTYPE_p_p_SoGeoOrigin swig_types[1061]
#define SWIGTYPE_p_p_SoGeoSeparator swig_types[1062]
#define SWIGTYPE_p_p_SoGroup swig_types[1063]
#define SWIGTYPE_p_p_SoHandleBoxDragger swig_types[1064]
#define SWIGTYPE_p_p_SoHandleBoxManip swig_types[1065]
#define SWIGTYPE_p_p_SoHeightMapToNormalMap swig_types[1066]
#define SWIGTYPE_p_p_SoImage swig_types[1067]
#define SWIGTYPE_p_p_SoIndexedFaceSet swig_types[1068]
#define SWIGTYPE_p_p_SoIndexedLineSet swig_types[1069]
#define SWIGTYPE_p_p_SoIndexedMarkerSet swig_types[1070]
#define SWIGTYPE_p_p_SoIndexedNurbsCurve swig_types[1071]
#define SWIGTYPE_p_p_SoIndexedNurbsSurface swig_types[1072]
#define SWIGTYPE_p_p_SoIndexedPointSet swig_types[1073]
#define SWIGTYPE_p_p_SoIndexedShape swig_types[1074]
#define SWIGTYPE_p_p_SoIndexedTriangleStripSet swig_types[1075]
#define SWIGTYPE_p_p_SoInfo swig_types[1076]
#define SWIGTYPE_p_p_SoInteractionKit swig_types[1077]
#define SWIGTYPE_p_p_SoInterpolate swig_types[1078]
#define SWIGTYPE_p_p_SoInterpolateFloat swig_types[1079]
#define SWIGTYPE_p_p_SoInterpolateRotation swig_types[1080]
#define SWIGTYPE_p_p_SoInterpolateVec2f swig_types[1081]
#define SWIGTYPE_p_p_SoInterpolateVec3f swig_types[1082]
#define SWIGTYPE_p_p_SoInterpolateVec4f swig_types[1083]
#define SWIGTYPE_p_p_SoJackDragger swig_types[1084]
#define SWIGTYPE_p_p_SoJackManip swig_types[1085]
#define SWIGTYPE_p_p_SoLOD swig_types[1086]
#define SWIGTYPE_p_p_SoLabel swig_types[1087]
#define SWIGTYPE_p_p_SoLevelOfDetail swig_types[1088]
#define SWIGTYPE_p_p_SoLight swig_types[1089]
#define SWIGTYPE_p_p_SoLightKit swig_types[1090]
#define SWIGTYPE_p_p_SoLightModel swig_types[1091]
#define SWIGTYPE_p_p_SoLineHighlightRenderAction swig_types[1092]
#define SWIGTYPE_p_p_SoLineSet swig_types[1093]
#define SWIGTYPE_p_p_SoLinearProfile swig_types[1094]
#define SWIGTYPE_p_p_SoListener swig_types[1095]
#define SWIGTYPE_p_p_SoLocateHighlight swig_types[1096]
#define SWIGTYPE_p_p_SoMFBitMask swig_types[1097]
#define SWIGTYPE_p_p_SoMFBool swig_types[1098]
#define SWIGTYPE_p_p_SoMFColor swig_types[1099]
#define SWIGTYPE_p_p_SoMFColorRGBA swig_types[1100]
#define SWIGTYPE_p_p_SoMFDouble swig_types[1101]
#define SWIGTYPE_p_p_SoMFEngine swig_types[1102]
#define SWIGTYPE_p_p_SoMFEnum swig_types[1103]
#define SWIGTYPE_p_p_SoMFFloat swig_types[1104]
#define SWIGTYPE_p_p_SoMFInt32 swig_types[1105]
#define SWIGTYPE_p_p_SoMFMatrix swig_types[1106]
#define SWIGTYPE_p_p_SoMFName swig_types[1107]
#define SWIGTYPE_p_p_SoMFNode swig_types[1108]
#define SWIGTYPE_p_p_SoMFPath swig_types[1109]
#define SWIGTYPE_p_p_SoMFPlane swig_types[1110]
#define SWIGTYPE_p_p_SoMFRotation swig_types[1111]
#define SWIGTYPE_p_p_SoMFShort swig_types[1112]
#define SWIGTYPE_p_p_SoMFString swig_types[1113]
#define SWIGTYPE_p_p_SoMFTime swig_types[1114]
#define SWIGTYPE_p_p_SoMFUInt32 swig_types[1115]
#define SWIGTYPE_p_p_SoMFUShort swig_types[1116]
#define SWIGTYPE_p_p_SoMFVec2b swig_types[1117]
#define SWIGTYPE_p_p_SoMFVec2d swig_types[1118]
#define SWIGTYPE_p_p_SoMFVec2f swig_types[1119]
#define SWIGTYPE_p_p_SoMFVec2i32 swig_types[1120]
#define SWIGTYPE_p_p_SoMFVec2s swig_types[1121]
#define SWIGTYPE_p_p_SoMFVec3b swig_types[1122]
#define SWIGTYPE_p_p_SoMFVec3d swig_types[1123]
#define SWIGTYPE_p_p_SoMFVec3f swig_types[1124]
#define SWIGTYPE_p_p_SoMFVec3i32 swig_types[1125]
#define SWIGTYPE_p_p_SoMFVec3s swig_types[1126]
#define SWIGTYPE_p_p_SoMFVec4b swig_types[1127]
#define SWIGTYPE_p_p_SoMFVec4d swig_types[1128]
#define SWIGTYPE_p_p_SoMFVec4f swig_types[1129]
#define SWIGTYPE_p_p_SoMFVec4i32 swig_types[1130]
#define SWIGTYPE_p_p_SoMFVec4s swig_types[1131]
#define SWIGTYPE_p_p_SoMFVec4ub swig_types[1132]
#define SWIGTYPE_p_p_SoMFVec4ui32 swig_types[1133]
#define SWIGTYPE_p_p_SoMFVec4us swig_types[1134]
#define SWIGTYPE_p_p_SoMField swig_types[1135]
#define SWIGTYPE_p_p_SoMarkerSet swig_types[1136]
#define SWIGTYPE_p_p_SoMaterial swig_types[1137]
#define SWIGTYPE_p_p_SoMaterialBinding swig_types[1138]
#define SWIGTYPE_p_p_SoMatrixTransform swig_types[1139]
#define SWIGTYPE_p_p_SoMultipleCopy swig_types[1140]
#define SWIGTYPE_p_p_SoNode swig_types[1141]
#define SWIGTYPE_p_p_SoNodeEngine swig_types[1142]
#define SWIGTYPE_p_p_SoNodeKitListPart swig_types[1143]
#define SWIGTYPE_p_p_SoNodeKitPath swig_types[1144]
#define SWIGTYPE_p_p_SoNonIndexedShape swig_types[1145]
#define SWIGTYPE_p_p_SoNormal swig_types[1146]
#define SWIGTYPE_p_p_SoNormalBinding swig_types[1147]
#define SWIGTYPE_p_p_SoNurbsCurve swig_types[1148]
#define SWIGTYPE_p_p_SoNurbsProfile swig_types[1149]
#define SWIGTYPE_p_p_SoNurbsSurface swig_types[1150]
#define SWIGTYPE_p_p_SoOnOff swig_types[1151]
#define SWIGTYPE_p_p_SoOneShot swig_types[1152]
#define SWIGTYPE_p_p_SoOrthographicCamera swig_types[1153]
#define SWIGTYPE_p_p_SoPackedColor swig_types[1154]
#define SWIGTYPE_p_p_SoPath swig_types[1155]
#define SWIGTYPE_p_p_SoPathSwitch swig_types[1156]
#define SWIGTYPE_p_p_SoPendulum swig_types[1157]
#define SWIGTYPE_p_p_SoPerspectiveCamera swig_types[1158]
#define SWIGTYPE_p_p_SoPickStyle swig_types[1159]
#define SWIGTYPE_p_p_SoPointLight swig_types[1160]
#define SWIGTYPE_p_p_SoPointLightDragger swig_types[1161]
#define SWIGTYPE_p_p_SoPointLightManip swig_types[1162]
#define SWIGTYPE_p_p_SoPointSet swig_types[1163]
#define SWIGTYPE_p_p_SoPolygonOffset swig_types[1164]
#define SWIGTYPE_p_p_SoProfile swig_types[1165]
#define SWIGTYPE_p_p_SoProfileCoordinate2 swig_types[1166]
#define SWIGTYPE_p_p_SoProfileCoordinate3 swig_types[1167]
#define SWIGTYPE_p_p_SoProto swig_types[1168]
#define SWIGTYPE_p_p_SoProtoInstance swig_types[1169]
#define SWIGTYPE_p_p_SoQuadMesh swig_types[1170]
#define SWIGTYPE_p_p_SoResetTransform swig_types[1171]
#define SWIGTYPE_p_p_SoReversePerspectiveCamera swig_types[1172]
#define SWIGTYPE_p_p_SoRotateCylindricalDragger swig_types[1173]
#define SWIGTYPE_p_p_SoRotateDiscDragger swig_types[1174]
#define SWIGTYPE_p_p_SoRotateSphericalDragger swig_types[1175]
#define SWIGTYPE_p_p_SoRotation swig_types[1176]
#define SWIGTYPE_p_p_SoRotationXYZ swig_types[1177]
#define SWIGTYPE_p_p_SoRotor swig_types[1178]
#define SWIGTYPE_p_p_SoSFBitMask swig_types[1179]
#define SWIGTYPE_p_p_SoSFBool swig_types[1180]
#define SWIGTYPE_p_p_SoSFBox2d swig_types[1181]
#define SWIGTYPE_p_p_SoSFBox2f swig_types[1182]
#define SWIGTYPE_p_p_SoSFBox2i32 swig_types[1183]
#define SWIGTYPE_p_p_SoSFBox2s swig_types[1184]
#define SWIGTYPE_p_p_SoSFBox3d swig_types[1185]
#define SWIGTYPE_p_p_SoSFBox3f swig_types[1186]
#define SWIGTYPE_p_p_SoSFBox3i32 swig_types[1187]
#define SWIGTYPE_p_p_SoSFBox3s swig_types[1188]
#define SWIGTYPE_p_p_SoSFColor swig_types[1189]
#define SWIGTYPE_p_p_SoSFColorRGBA swig_types[1190]
#define SWIGTYPE_p_p_SoSFDouble swig_types[1191]
#define SWIGTYPE_p_p_SoSFEngine swig_types[1192]
#define SWIGTYPE_p_p_SoSFEnum swig_types[1193]
#define SWIGTYPE_p_p_SoSFFloat swig_types[1194]
#define SWIGTYPE_p_p_SoSFImage swig_types[1195]
#define SWIGTYPE_p_p_SoSFImage3 swig_types[1196]
#define SWIGTYPE_p_p_SoSFInt32 swig_types[1197]
#define SWIGTYPE_p_p_SoSFMatrix swig_types[1198]
#define SWIGTYPE_p_p_SoSFName swig_types[1199]
#define SWIGTYPE_p_p_SoSFNode swig_types[1200]
#define SWIGTYPE_p_p_SoSFPath swig_types[1201]
#define SWIGTYPE_p_p_SoSFPlane swig_types[1202]
#define SWIGTYPE_p_p_SoSFRotation swig_types[1203]
#define SWIGTYPE_p_p_SoSFShort swig_types[1204]
#define SWIGTYPE_p_p_SoSFString swig_types[1205]
#define SWIGTYPE_p_p_SoSFTime swig_types[1206]
#define SWIGTYPE_p_p_SoSFTrigger swig_types[1207]
#define SWIGTYPE_p_p_SoSFUInt32 swig_types[1208]
#define SWIGTYPE_p_p_SoSFUShort swig_types[1209]
#define SWIGTYPE_p_p_SoSFVec2b swig_types[1210]
#define SWIGTYPE_p_p_SoSFVec2d swig_types[1211]
#define SWIGTYPE_p_p_SoSFVec2f swig_types[1212]
#define SWIGTYPE_p_p_SoSFVec2i32 swig_types[1213]
#define SWIGTYPE_p_p_SoSFVec2s swig_types[1214]
#define SWIGTYPE_p_p_SoSFVec3b swig_types[1215]
#define SWIGTYPE_p_p_SoSFVec3d swig_types[1216]
#define SWIGTYPE_p_p_SoSFVec3f swig_types[1217]
#define SWIGTYPE_p_p_SoSFVec3i32 swig_types[1218]
#define SWIGTYPE_p_p_SoSFVec3s swig_types[1219]
#define SWIGTYPE_p_p_SoSFVec4b swig_types[1220]
#define SWIGTYPE_p_p_SoSFVec4d swig_types[1221]
#define SWIGTYPE_p_p_SoSFVec4f swig_types[1222]
#define SWIGTYPE_p_p_SoSFVec4i32 swig_types[1223]
#define SWIGTYPE_p_p_SoSFVec4s swig_types[1224]
#define SWIGTYPE_p_p_SoSFVec4ub swig_types[1225]
#define SWIGTYPE_p_p_SoSFVec4ui32 swig_types[1226]
#define SWIGTYPE_p_p_SoSFVec4us swig_types[1227]
#define SWIGTYPE_p_p_SoSField swig_types[1228]
#define SWIGTYPE_p_p_SoScale swig_types[1229]
#define SWIGTYPE_p_p_SoScale1Dragger swig_types[1230]
#define SWIGTYPE_p_p_SoScale2Dragger swig_types[1231]
#define SWIGTYPE_p_p_SoScale2UniformDragger swig_types[1232]
#define SWIGTYPE_p_p_SoScaleUniformDragger swig_types[1233]
#define SWIGTYPE_p_p_SoSceneKit swig_types[1234]
#define SWIGTYPE_p_p_SoSceneTexture2 swig_types[1235]
#define SWIGTYPE_p_p_SoSceneTextureCubeMap swig_types[1236]
#define SWIGTYPE_p_p_SoSelectOne swig_types[1237]
#define SWIGTYPE_p_p_SoSelection swig_types[1238]
#define SWIGTYPE_p_p_SoSeparator swig_types[1239]
#define SWIGTYPE_p_p_SoSeparatorKit swig_types[1240]
#define SWIGTYPE_p_p_SoShaderObject swig_types[1241]
#define SWIGTYPE_p_p_SoShaderParameter swig_types[1242]
#define SWIGTYPE_p_p_SoShaderParameter1f swig_types[1243]
#define SWIGTYPE_p_p_SoShaderParameter1i swig_types[1244]
#define SWIGTYPE_p_p_SoShaderParameter2f swig_types[1245]
#define SWIGTYPE_p_p_SoShaderParameter2i swig_types[1246]
#define SWIGTYPE_p_p_SoShaderParameter3f swig_types[1247]
#define SWIGTYPE_p_p_SoShaderParameter3i swig_types[1248]
#define SWIGTYPE_p_p_SoShaderParameter4f swig_types[1249]
#define SWIGTYPE_p_p_SoShaderParameter4i swig_types[1250]
#define SWIGTYPE_p_p_SoShaderParameterArray1f swig_types[1251]
#define SWIGTYPE_p_p_SoShaderParameterArray1i swig_types[1252]
#define SWIGTYPE_p_p_SoShaderParameterArray2f swig_types[1253]
#define SWIGTYPE_p_p_SoShaderParameterArray2i swig_types[1254]
#define SWIGTYPE_p_p_SoShaderParameterArray3f swig_types[1255]
#define SWIGTYPE_p_p_SoShaderParameterArray3i swig_types[1256]
#define SWIGTYPE_p_p_SoShaderParameterArray4f swig_types[1257]
#define SWIGTYPE_p_p_SoShaderParameterArray4i swig_types[1258]
#define SWIGTYPE_p_p_SoShaderParameterMatrix swig_types[1259]
#define SWIGTYPE_p_p_SoShaderParameterMatrixArray swig_types[1260]
#define SWIGTYPE_p_p_SoShaderProgram swig_types[1261]
#define SWIGTYPE_p_p_SoShaderStateMatrixParameter swig_types[1262]
#define SWIGTYPE_p_p_SoShape swig_types[1263]
#define SWIGTYPE_p_p_SoShapeHints swig_types[1264]
#define SWIGTYPE_p_p_SoShapeKit swig_types[1265]
#define SWIGTYPE_p_p_SoShuttle swig_types[1266]
#define SWIGTYPE_p_p_SoSphere swig_types[1267]
#define SWIGTYPE_p_p_SoSpotLight swig_types[1268]
#define SWIGTYPE_p_p_SoSpotLightDragger swig_types[1269]
#define SWIGTYPE_p_p_SoSpotLightManip swig_types[1270]
#define SWIGTYPE_p_p_SoSurroundScale swig_types[1271]
#define SWIGTYPE_p_p_SoSwitch swig_types[1272]
#define SWIGTYPE_p_p_SoTabBoxDragger swig_types[1273]
#define SWIGTYPE_p_p_SoTabBoxManip swig_types[1274]
#define SWIGTYPE_p_p_SoTabPlaneDragger swig_types[1275]
#define SWIGTYPE_p_p_SoTempPath swig_types[1276]
#define SWIGTYPE_p_p_SoText2 swig_types[1277]
#define SWIGTYPE_p_p_SoText3 swig_types[1278]
#define SWIGTYPE_p_p_SoTexture swig_types[1279]
#define SWIGTYPE_p_p_SoTexture2 swig_types[1280]
#define SWIGTYPE_p_p_SoTexture2Convert swig_types[1281]
#define SWIGTYPE_p_p_SoTexture2Transform swig_types[1282]
#define SWIGTYPE_p_p_SoTexture3 swig_types[1283]
#define SWIGTYPE_p_p_SoTexture3Transform swig_types[1284]
#define SWIGTYPE_p_p_SoTextureCombine swig_types[1285]
#define SWIGTYPE_p_p_SoTextureCoordinate2 swig_types[1286]
#define SWIGTYPE_p_p_SoTextureCoordinate3 swig_types[1287]
#define SWIGTYPE_p_p_SoTextureCoordinateBinding swig_types[1288]
#define SWIGTYPE_p_p_SoTextureCoordinateCube swig_types[1289]
#define SWIGTYPE_p_p_SoTextureCoordinateCylinder swig_types[1290]
#define SWIGTYPE_p_p_SoTextureCoordinateDefault swig_types[1291]
#define SWIGTYPE_p_p_SoTextureCoordinateEnvironment swig_types[1292]
#define SWIGTYPE_p_p_SoTextureCoordinateFunction swig_types[1293]
#define SWIGTYPE_p_p_SoTextureCoordinateNormalMap swig_types[1294]
#define SWIGTYPE_p_p_SoTextureCoordinateObject swig_types[1295]
#define SWIGTYPE_p_p_SoTextureCoordinatePlane swig_types[1296]
#define SWIGTYPE_p_p_SoTextureCoordinateReflectionMap swig_types[1297]
#define SWIGTYPE_p_p_SoTextureCoordinateSphere swig_types[1298]
#define SWIGTYPE_p_p_SoTextureCubeMap swig_types[1299]
#define SWIGTYPE_p_p_SoTextureMatrixTransform swig_types[1300]
#define SWIGTYPE_p_p_SoTextureScalePolicy swig_types[1301]
#define SWIGTYPE_p_p_SoTextureUnit swig_types[1302]
#define SWIGTYPE_p_p_SoTimeCounter swig_types[1303]
#define SWIGTYPE_p_p_SoTrackballDragger swig_types[1304]
#define SWIGTYPE_p_p_SoTrackballManip swig_types[1305]
#define SWIGTYPE_p_p_SoTransform swig_types[1306]
#define SWIGTYPE_p_p_SoTransformBoxDragger swig_types[1307]
#define SWIGTYPE_p_p_SoTransformBoxManip swig_types[1308]
#define SWIGTYPE_p_p_SoTransformManip swig_types[1309]
#define SWIGTYPE_p_p_SoTransformSeparator swig_types[1310]
#define SWIGTYPE_p_p_SoTransformVec3f swig_types[1311]
#define SWIGTYPE_p_p_SoTransformation swig_types[1312]
#define SWIGTYPE_p_p_SoTransformerDragger swig_types[1313]
#define SWIGTYPE_p_p_SoTransformerManip swig_types[1314]
#define SWIGTYPE_p_p_SoTranslate1Dragger swig_types[1315]
#define SWIGTYPE_p_p_SoTranslate2Dragger swig_types[1316]
#define SWIGTYPE_p_p_SoTranslation swig_types[1317]
#define SWIGTYPE_p_p_SoTransparencyType swig_types[1318]
#define SWIGTYPE_p_p_SoTriangleStripSet swig_types[1319]
#define SWIGTYPE_p_p_SoTriggerAny swig_types[1320]
#define SWIGTYPE_p_p_SoUniformShaderParameter swig_types[1321]
#define SWIGTYPE_p_p_SoUnits swig_types[1322]
#define SWIGTYPE_p_p_SoVRMLAnchor swig_types[1323]
#define SWIGTYPE_p_p_SoVRMLAppearance swig_types[1324]
#define SWIGTYPE_p_p_SoVRMLAudioClip swig_types[1325]
#define SWIGTYPE_p_p_SoVRMLBackground swig_types[1326]
#define SWIGTYPE_p_p_SoVRMLBillboard swig_types[1327]
#define SWIGTYPE_p_p_SoVRMLBox swig_types[1328]
#define SWIGTYPE_p_p_SoVRMLCollision swig_types[1329]
#define SWIGTYPE_p_p_SoVRMLColor swig_types[1330]
#define SWIGTYPE_p_p_SoVRMLColorInterpolator swig_types[1331]
#define SWIGTYPE_p_p_SoVRMLCone swig_types[1332]
#define SWIGTYPE_p_p_SoVRMLCoordinate swig_types[1333]
#define SWIGTYPE_p_p_SoVRMLCoordinateInterpolator swig_types[1334]
#define SWIGTYPE_p_p_SoVRMLCylinder swig_types[1335]
#define SWIGTYPE_p_p_SoVRMLCylinderSensor swig_types[1336]
#define SWIGTYPE_p_p_SoVRMLDirectionalLight swig_types[1337]
#define SWIGTYPE_p_p_SoVRMLDragSensor swig_types[1338]
#define SWIGTYPE_p_p_SoVRMLElevationGrid swig_types[1339]
#define SWIGTYPE_p_p_SoVRMLExtrusion swig_types[1340]
#define SWIGTYPE_p_p_SoVRMLFog swig_types[1341]
#define SWIGTYPE_p_p_SoVRMLFontStyle swig_types[1342]
#define SWIGTYPE_p_p_SoVRMLGeometry swig_types[1343]
#define SWIGTYPE_p_p_SoVRMLGroup swig_types[1344]
#define SWIGTYPE_p_p_SoVRMLImageTexture swig_types[1345]
#define SWIGTYPE_p_p_SoVRMLIndexedFaceSet swig_types[1346]
#define SWIGTYPE_p_p_SoVRMLIndexedLine swig_types[1347]
#define SWIGTYPE_p_p_SoVRMLIndexedLineSet swig_types[1348]
#define SWIGTYPE_p_p_SoVRMLIndexedShape swig_types[1349]
#define SWIGTYPE_p_p_SoVRMLInline swig_types[1350]
#define SWIGTYPE_p_p_SoVRMLInterpolator swig_types[1351]
#define SWIGTYPE_p_p_SoVRMLLOD swig_types[1352]
#define SWIGTYPE_p_p_SoVRMLLight swig_types[1353]
#define SWIGTYPE_p_p_SoVRMLMaterial swig_types[1354]
#define SWIGTYPE_p_p_SoVRMLMovieTexture swig_types[1355]
#define SWIGTYPE_p_p_SoVRMLNavigationInfo swig_types[1356]
#define SWIGTYPE_p_p_SoVRMLNormal swig_types[1357]
#define SWIGTYPE_p_p_SoVRMLNormalInterpolator swig_types[1358]
#define SWIGTYPE_p_p_SoVRMLOrientationInterpolator swig_types[1359]
#define SWIGTYPE_p_p_SoVRMLParent swig_types[1360]
#define SWIGTYPE_p_p_SoVRMLPixelTexture swig_types[1361]
#define SWIGTYPE_p_p_SoVRMLPlaneSensor swig_types[1362]
#define SWIGTYPE_p_p_SoVRMLPointLight swig_types[1363]
#define SWIGTYPE_p_p_SoVRMLPointSet swig_types[1364]
#define SWIGTYPE_p_p_SoVRMLPositionInterpolator swig_types[1365]
#define SWIGTYPE_p_p_SoVRMLProximitySensor swig_types[1366]
#define SWIGTYPE_p_p_SoVRMLScalarInterpolator swig_types[1367]
#define SWIGTYPE_p_p_SoVRMLScript swig_types[1368]
#define SWIGTYPE_p_p_SoVRMLSensor swig_types[1369]
#define SWIGTYPE_p_p_SoVRMLShape swig_types[1370]
#define SWIGTYPE_p_p_SoVRMLSound swig_types[1371]
#define SWIGTYPE_p_p_SoVRMLSphere swig_types[1372]
#define SWIGTYPE_p_p_SoVRMLSphereSensor swig_types[1373]
#define SWIGTYPE_p_p_SoVRMLSpotLight swig_types[1374]
#define SWIGTYPE_p_p_SoVRMLSwitch swig_types[1375]
#define SWIGTYPE_p_p_SoVRMLText swig_types[1376]
#define SWIGTYPE_p_p_SoVRMLTexture swig_types[1377]
#define SWIGTYPE_p_p_SoVRMLTextureCoordinate swig_types[1378]
#define SWIGTYPE_p_p_SoVRMLTextureTransform swig_types[1379]
#define SWIGTYPE_p_p_SoVRMLTimeSensor swig_types[1380]
#define SWIGTYPE_p_p_SoVRMLTouchSensor swig_types[1381]
#define SWIGTYPE_p_p_SoVRMLTransform swig_types[1382]
#define SWIGTYPE_p_p_SoVRMLVertexLine swig_types[1383]
#define SWIGTYPE_p_p_SoVRMLVertexPoint swig_types[1384]
#define SWIGTYPE_p_p_SoVRMLVertexShape swig_types[1385]
#define SWIGTYPE_p_p_SoVRMLViewpoint swig_types[1386]
#define SWIGTYPE_p_p_SoVRMLVisibilitySensor swig_types[1387]
#define SWIGTYPE_p_p_SoVRMLWorldInfo swig_types[1388]
#define SWIGTYPE_p_p_SoVertexAttribute swig_types[1389]
#define SWIGTYPE_p_p_SoVertexAttributeBinding swig_types[1390]
#define SWIGTYPE_p_p_SoVertexProperty swig_types[1391]
#define SWIGTYPE_p_p_SoVertexShader swig_types[1392]
#define SWIGTYPE_p_p_SoVertexShape swig_types[1393]
#define SWIGTYPE_p_p_SoWWWAnchor swig_types[1394]
#define SWIGTYPE_p_p_SoWWWInline swig_types[1395]
#define SWIGTYPE_p_p_SoWrapperKit swig_types[1396]
#define SWIGTYPE_p_p_char swig_types[1397]
#define SWIGTYPE_p_p_charp swig_types[1398]
#define SWIGTYPE_p_p_f_p_SoAction_p_SoNode__void swig_types[1399]
#define SWIGTYPE_p_p_f_p_void__SoGLRenderAction__AbortCode swig_types[1400]
#define SWIGTYPE_p_p_f_p_void_p_SoInput__void swig_types[1401]
#define SWIGTYPE_p_p_float swig_types[1402]
#define SWIGTYPE_p_p_floatp swig_types[1403]
#define SWIGTYPE_p_p_int swig_types[1404]
#define SWIGTYPE_p_p_intp swig_types[1405]
#define SWIGTYPE_p_p_unsigned_char swig_types[1406]
#define SWIGTYPE_p_p_void swig_types[1407]
#define SWIGTYPE_p_read_func swig_types[1408]
#define SWIGTYPE_p_seek_func swig_types[1409]
#define SWIGTYPE_p_short swig_types[1410]
#define SWIGTYPE_p_signed_char swig_types[1411]
#define SWIGTYPE_p_size_t swig_types[1412]
#define SWIGTYPE_p_std__FILE swig_types[1413]
#define SWIGTYPE_p_tell_func swig_types[1414]
#define SWIGTYPE_p_time_t swig_types[1415]
#define SWIGTYPE_p_timeval swig_types[1416]
#define SWIGTYPE_p_unsigned_char swig_types[1417]
#define SWIGTYPE_p_unsigned_int swig_types[1418]
#define SWIGTYPE_p_unsigned_long_long swig_types[1419]
#define SWIGTYPE_p_unsigned_short swig_types[1420]
#define SWIGTYPE_p_void swig_types[1421]
#define SWIGTYPE_p_wchar_t swig_types[1422]
static swig_type_info *swig_types[1424];
static swig_module_info swig_module = {swig_types, 1423, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _coin.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__coin

#else
#  define SWIG_init    init_coin

#endif

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include <stdint.h>		// Use the C99 official header


#if defined(_WIN32) || defined(__WIN32__)
#include <windows.h>
#undef max
#undef ERROR
#undef DELETE
#endif

#undef ANY

#include "coin_header_includes.h"

/* make GLState in SoGLLazyElement known to SWIG */
typedef SoGLLazyElement::GLState GLState;


/*
  Workaround for FILE* typemap. Import IO module instead of using extern PyTypeObject PyIOBase_Type,
  because the windows python lib does not export PyIOBase_Type.
  Copied from: https://github.com/Kagami/pygraphviz/commit/fe442dc16accb629c3feaf157af75f67ccabbd6e
*/
#if PY_MAJOR_VERSION >= 3
static PyObject *PyIOBase_TypeObj;

static int init_file_emulator(void)
{
    PyObject *io = PyImport_ImportModule("_io");
    if (io == NULL)
        return -1;
    PyIOBase_TypeObj = PyObject_GetAttrString(io, "_IOBase");
    if (PyIOBase_TypeObj == NULL)
        return -1;
    return 0;
}
#endif


#include <Inventor/SbTime.h>

#if (PY_VERSION_HEX < 0x02050000)
/* Py_ssize_t needed for Python 2.5 compatibility, but isn't defined
 * in earlier Python versions. */
typedef int Py_ssize_t;
#endif

#if PY_MAJOR_VERSION >= 3
  #define IS_PY3K
#endif

PyObject *
cast_internal(PyObject * self, PyObject * obj, const char * type_name, Py_ssize_t type_len)
{
  swig_type_info * swig_type = 0;
  void * cast_obj = 0;
  char * ptr_type;

  /*
   * add a pointer sign to the string coming from the interpreter
   * e.g. "SoSeparator" becomes "SoSeparator *" - so that SWIG_TypeQuery()
   * can do its job.
   */
  if (!(ptr_type = (char*)malloc(type_len+3))) { SWIG_fail; }

  memset(ptr_type, 0, type_len+3);
  strncpy(ptr_type, type_name, type_len);
  strcat(ptr_type, " *");

  if (!(swig_type = SWIG_TypeQuery(ptr_type))) {
    /* the britney maneuver: "baby one more time" by prefixing 'So' */
    char * cast_name = (char*)malloc(type_len + 5);
    memset(cast_name, 0, type_len + 5);
    cast_name[0] = 'S'; cast_name[1] = 'o';
    strncpy(cast_name+2, ptr_type, type_len+2);

    if (!(swig_type = SWIG_TypeQuery(cast_name))) {
      free(cast_name); free(ptr_type);
      SWIG_fail;
    }

    free(cast_name);
  }

  free(ptr_type);

  SWIG_ConvertPtr(obj, (void**)&cast_obj, NULL, SWIG_POINTER_EXCEPTION | 0);
  if (SWIG_arg_fail(1)) { SWIG_fail; }

  return SWIG_NewPointerObj((void*)cast_obj, swig_type, 0);
fail:
  return NULL;
}

/* a casting helper function */
SWIGEXPORT PyObject *
cast(PyObject * self, PyObject * args)
{
  char * type_name;
  Py_ssize_t type_len;
  PyObject * obj = 0;

  if (!PyArg_ParseTuple(args, "Os#:cast", &obj, &type_name, &type_len)) {
    SWIG_fail;
  }

  return cast_internal(self, obj, type_name, type_len);
fail:
  return NULL;
}

/* autocasting helper function for SoBase */
SWIGEXPORT PyObject *
autocast_base(SoBase * base)
{
  PyObject * result = NULL;

  /* autocast the result to the corresponding type */
  if (base && base->isOfType(SoFieldContainer::getClassTypeId())) {
    PyObject * obj = NULL;
    SoType type = base->getTypeId();

    /* in case of a non built-in type get the closest built-in parent */
    while (!(type.isBad() || result)) {
      obj = SWIG_NewPointerObj((void*)base, SWIGTYPE_p_SoBase, 0);
      
      result = cast_internal(NULL, obj, type.getName().getString(), type.getName().getLength());

      Py_DECREF(obj);

      if (!result) { type = type.getParent(); }
    }
  }      

  if (!result) {
    Py_INCREF(Py_None);
    result = Py_None;
  }

  return result;
}

/* autocasting helper function for SoPath */
SWIGEXPORT PyObject *
autocast_path(SoPath * path)
{
  PyObject * result = NULL;
  
  /* autocast the result to the corresponding type */
  if (path) {
    PyObject * obj = NULL;
    SoType type = path->getTypeId();

    /* in case of a non built-in type get the closest built-in parent */
    while (!(type.isBad() || result)) {
      obj = SWIG_NewPointerObj((void*)path, SWIGTYPE_p_SoPath, 0);
      
      result = cast_internal(NULL, obj, type.getName().getString(), type.getName().getLength());

      Py_DECREF(obj);

      if (!result) { type = type.getParent(); }
    }
  }

  if (!result) {
    Py_INCREF(Py_None);
    result = Py_None;
  }

  return result;
}

/* autocasting helper function for SoField */
SWIGEXPORT PyObject *
autocast_field(SoField * field)
{
  PyObject * result = NULL;

  /* autocast the result to the corresponding type */
  if (field) {
    PyObject * obj = NULL;
    SoType type = field->getTypeId();

    /* in case of a non built-in type get the closest built-in parent */
    while (!(type.isBad() || result)) {
      obj = SWIG_NewPointerObj((void*)field, SWIGTYPE_p_SoField, 0);
      
      result = cast_internal(NULL, obj, type.getName().getString(), type.getName().getLength());

      Py_DECREF(obj);
      
      if (!result) { type = type.getParent(); }
    }
  }

  if (!result) {
    Py_INCREF(Py_None);
    result = Py_None;
  }

  return result;
}

/* autocasting helper function for SoEvent */
SWIGEXPORT PyObject *
autocast_event(SoEvent * event)
{
  PyObject * result = NULL;
  
  /* autocast the result to the corresponding type */
  if (event) {
    PyObject * obj = NULL;
    SoType type = event->getTypeId();

    /* in case of a non built-in type get the closest built-in parent */
    while (!(type.isBad() || result)) {
      obj = SWIG_NewPointerObj((void*)event, SWIGTYPE_p_SoEvent, 0);
      
      result = cast_internal(NULL, obj, type.getName().getString(), type.getName().getLength());

      Py_DECREF(obj);

      if (!result) { type = type.getParent(); }
    }
  }

  if (!result) {
    Py_INCREF(Py_None);
    result = Py_None;
  }

  return result;
}


typedef char charp;

SWIGINTERN charp *new_charp(){
    return (new char());
  }
SWIGINTERN void delete_charp(charp *self){
    delete self;
  }

SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static swig_type_info* info = 0;
  if (!info) {
    info = SWIG_TypeQuery("_p_char");
  }
  return info;
}


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX >= 0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX < 0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <errno.h>


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}

SWIGINTERN void charp_assign(charp *self,char value){
    *self = value;
  }
SWIGINTERN char charp_value(charp *self){
    return *self;
  }

SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > (size_t)PY_SSIZE_T_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}

SWIGINTERN char *charp_cast(charp *self){
    return self;
  }

SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}




SWIGINTERN charp *charp_frompointer(char *t){
    return (charp *) t;
  }

typedef int intp;

SWIGINTERN intp *new_intp(){
    return (new int());
  }
SWIGINTERN void delete_intp(intp *self){
    delete self;
  }

SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}

SWIGINTERN void intp_assign(intp *self,int value){
    *self = value;
  }
SWIGINTERN int intp_value(intp *self){
    return *self;
  }

SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}

SWIGINTERN int *intp_cast(intp *self){
    return self;
  }
SWIGINTERN intp *intp_frompointer(int *t){
    return (intp *) t;
  }

typedef long longp;

SWIGINTERN longp *new_longp(){
    return (new long());
  }
SWIGINTERN void delete_longp(longp *self){
    delete self;
  }
SWIGINTERN void longp_assign(longp *self,long value){
    *self = value;
  }
SWIGINTERN long longp_value(longp *self){
    return *self;
  }

  #define SWIG_From_long   PyInt_FromLong 

SWIGINTERN long *longp_cast(longp *self){
    return self;
  }
SWIGINTERN longp *longp_frompointer(long *t){
    return (longp *) t;
  }

typedef float floatp;

SWIGINTERN floatp *new_floatp(){
    return (new float());
  }
SWIGINTERN void delete_floatp(floatp *self){
    delete self;
  }

/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99 */
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(__cplusplus) && __cplusplus >= 201103L
/* Use a template so that this works whether isfinite() is std::isfinite() or
 * in the global namespace.  The reality seems to vary between compiler
 * versions.
 *
 * Make sure namespace std exists to avoid compiler warnings.
 *
 * extern "C++" is required as this fragment can end up inside an extern "C" { } block
 */
namespace std { }
extern "C++" template<typename T>
inline int SWIG_isfinite_func(T x) {
  using namespace std;
  return isfinite(x);
}
#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#  define SWIG_isfinite(X) (__builtin_isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}

SWIGINTERN void floatp_assign(floatp *self,float value){
    *self = value;
  }
SWIGINTERN float floatp_value(floatp *self){
    return *self;
  }

  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}

SWIGINTERN float *floatp_cast(floatp *self){
    return self;
  }
SWIGINTERN floatp *floatp_frompointer(float *t){
    return (floatp *) t;
  }

typedef double doublep;

SWIGINTERN doublep *new_doublep(){
    return (new double());
  }
SWIGINTERN void delete_doublep(doublep *self){
    delete self;
  }
SWIGINTERN void doublep_assign(doublep *self,double value){
    *self = value;
  }
SWIGINTERN double doublep_value(doublep *self){
    return *self;
  }
SWIGINTERN double *doublep_cast(doublep *self){
    return self;
  }
SWIGINTERN doublep *doublep_frompointer(double *t){
    return (doublep *) t;
  }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}

SWIGINTERN PyObject *SoType_createInstance(SoType *self){
    if (self->isDerivedFrom(SoField::getClassTypeId())) {
      return autocast_field((SoField*)self->createInstance());
    } else if (self->isDerivedFrom(SoPath::getClassTypeId())) {
      return autocast_path((SoPath*)self->createInstance());
    }
    return autocast_base((SoBase*)self->createInstance());
  }

static void
convert_SbVec2s_array(PyObject *input, short temp[2])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 2) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1))) {
    temp[0] = PyInt_AsLong(PySequence_GetItem(input, 0));
    temp[1] = PyInt_AsLong(PySequence_GetItem(input, 1));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 2 shorts");
    PyErr_Print();
  } 
}

SWIGINTERN void *SbPList___getitem__(SbPList *self,int i){ return self->get(i); }
SWIGINTERN void SbPList___setitem__(SbPList *self,int i,void *val){ self->set(i,val); }
SWIGINTERN void SbIntList___setitem__(SbIntList *self,int const i,int *value){ self->set(i,value); }
SWIGINTERN int &SbIntList___getitem__(SbIntList *self,int const i){ return (*self)[i]; }
SWIGINTERN int SbIntList_get(SbIntList *self,int const i){ return (*self)[i]; }

SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}

SWIGINTERN int SbString___eq____SWIG_0(SbString *self,SbString const &u){ return *self == u; }
SWIGINTERN int SbString___nq____SWIG_0(SbString *self,SbString const &u){ return *self != u; }
SWIGINTERN int SbString___eq____SWIG_1(SbString *self,char *u){ return *self == u; }
SWIGINTERN int SbString___nq____SWIG_1(SbString *self,char *u){ return *self != u; }
SWIGINTERN char SbString___getitem__(SbString *self,int i){ return (*self)[i]; }
SWIGINTERN char const *SbString___repr__(SbString *self){ return self->getString(); }
SWIGINTERN int SbName___eq____SWIG_0(SbName *self,SbName const &u){ return *self == u; }
SWIGINTERN int SbName___nq____SWIG_0(SbName *self,SbName const &u){ return *self != u; }
SWIGINTERN int SbName___eq____SWIG_1(SbName *self,char *u){ return *self == u; }
SWIGINTERN int SbName___nq____SWIG_1(SbName *self,char *u){ return *self != u; }
SWIGINTERN int SbName___eq____SWIG_2(SbName *self,SbString const &u){ return *self == u.getString(); }
SWIGINTERN int SbName___nq____SWIG_2(SbName *self,SbString const &u){ return *self != u.getString(); }
SWIGINTERN char SbName___getitem__(SbName *self,int i){ return self->getString()[i]; }
SWIGINTERN char const *SbName___repr__(SbName *self){ return self->getString(); }

SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< short >(v);
    }
  }  
  return res;
}

SWIGINTERN SbVec2s SbVec2s___add__(SbVec2s *self,SbVec2s const &u){ return *self + u; }
SWIGINTERN SbVec2s SbVec2s___sub__(SbVec2s *self,SbVec2s const &u){ return *self - u; }
SWIGINTERN SbVec2s SbVec2s___mul__(SbVec2s *self,double const d){ return *self * d; }
SWIGINTERN SbVec2s SbVec2s___rmul__(SbVec2s *self,double const d){ return *self * d; }
SWIGINTERN SbVec2s SbVec2s___div__(SbVec2s *self,double const d){ return *self / d; }
SWIGINTERN SbVec2s SbVec2s___truediv__(SbVec2s *self,double const d){ return *self / d; }
SWIGINTERN int SbVec2s___eq__(SbVec2s *self,SbVec2s const &u){ return *self == u; }
SWIGINTERN int SbVec2s___nq__(SbVec2s *self,SbVec2s const &u){ return *self != u; }
SWIGINTERN short SbVec2s___getitem__(SbVec2s *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec2s___setitem__(SbVec2s *self,int i,short value){ (*self)[i] = value; }

static void
convert_SbVec2f_array(PyObject *input, float temp[2])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 2) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 2 floats");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec2f SbVec2f___add__(SbVec2f *self,SbVec2f const &u){ return *self + u; }
SWIGINTERN SbVec2f SbVec2f___sub__(SbVec2f *self,SbVec2f const &u){ return *self - u; }
SWIGINTERN SbVec2f SbVec2f___mul__(SbVec2f *self,float const d){ return *self * d; }
SWIGINTERN SbVec2f SbVec2f___rmul__(SbVec2f *self,float const d){ return *self * d; }
SWIGINTERN SbVec2f SbVec2f___div__(SbVec2f *self,float const d){ return *self / d; }
SWIGINTERN SbVec2f SbVec2f___truediv__(SbVec2f *self,float const d){ return *self / d; }
SWIGINTERN int SbVec2f___eq__(SbVec2f *self,SbVec2f const &u){ return *self == u; }
SWIGINTERN int SbVec2f___nq__(SbVec2f *self,SbVec2f const &u){ return *self != u; }
SWIGINTERN float SbVec2f___getitem__(SbVec2f *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec2f___setitem__(SbVec2f *self,int i,float value){ (*self)[i] = value; }
SWIGINTERN SbTime SbTime___add__(SbTime *self,SbTime const &u){ return *self + u; }
SWIGINTERN SbTime SbTime___sub__(SbTime *self,SbTime const &u){ return *self - u; }
SWIGINTERN SbTime SbTime___mul__(SbTime *self,double const d){ return *self * d; }
SWIGINTERN SbTime SbTime___rmul__(SbTime *self,double const d){ return *self * d; }
SWIGINTERN SbTime SbTime___div__(SbTime *self,double const d){ return *self / d; }

#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif

SWIGINTERN SbString SoField_get(SoField *self){
    SbString valuestring;
    self->get(valuestring);
    return valuestring;
  }
SWIGINTERN int SoMField___len__(SoMField *self){ return self->getNum(); }
SWIGINTERN SbString SoMField_get1(SoMField *self,int const index){
    SbString valuestring;
    self->get1(index, valuestring);
    return valuestring;
  }
SWIGINTERN void delete_SoBase(SoBase *self){ self->unref();}
SWIGINTERN size_t SoBase___hash__(SoBase *self){ return (size_t) self; }

SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN void SoBaseList___setitem__(SoBaseList *self,int const i,SoBase *value){ self->set(i,value); }
SWIGINTERN SoBase *SoBaseList___getitem__(SoBaseList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoBase *SoBaseList_get(SoBaseList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoNodeList___setitem__(SoNodeList *self,int const i,SoNode *value){ self->set(i,value); }
SWIGINTERN SoNode *SoNodeList___getitem__(SoNodeList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoNode *SoNodeList_get(SoNodeList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoDetailList___setitem__(SoDetailList *self,int const i,SoDetail *value){ self->set(i,value); }
SWIGINTERN SoDetail *SoDetailList___getitem__(SoDetailList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoDetail *SoDetailList_get(SoDetailList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoTypeList___setitem__(SoTypeList *self,int const i,SoType value){ self->set(i,value); }
SWIGINTERN SoType SoTypeList___getitem__(SoTypeList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoType SoTypeList_get(SoTypeList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoEngineOutputList___setitem__(SoEngineOutputList *self,int const i,SoEngineOutput *value){ self->set(i,value); }
SWIGINTERN SoEngineOutput *SoEngineOutputList___getitem__(SoEngineOutputList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoEngineOutput *SoEngineOutputList_get(SoEngineOutputList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoEngineList___setitem__(SoEngineList *self,int const i,SoEngine *value){ self->set(i,value); }
SWIGINTERN SoEngine *SoEngineList___getitem__(SoEngineList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoEngine *SoEngineList_get(SoEngineList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoFieldList___setitem__(SoFieldList *self,int const i,SoField *value){ self->set(i,value); }
SWIGINTERN SoField *SoFieldList___getitem__(SoFieldList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoField *SoFieldList_get__SWIG_1(SoFieldList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoPathList___setitem__(SoPathList *self,int const i,SoPath *value){ self->set(i,value); }
SWIGINTERN SoPath *SoPathList___getitem__(SoPathList *self,int i){ return (*self)[i]; }
SWIGINTERN SoPath *SoPathList_get(SoPathList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SoPickedPointList___setitem__(SoPickedPointList *self,int const i,SoPickedPoint *value){ self->set(i,value); }
SWIGINTERN SoPickedPoint *SoPickedPointList___getitem__(SoPickedPointList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoPickedPoint *SoPickedPointList_get(SoPickedPointList *self,int const i){ return (*self)[i]; }
SWIGINTERN int SoPath___eq__(SoPath *self,SoPath const &u){ return *self == u; }
SWIGINTERN int SoPath___nq__(SoPath *self,SoPath const &u){ return *self != u; }
SWIGINTERN SoFullPath *SoFullPath_fromSoPath(SoPath *path){
    return static_cast<SoFullPath *>(path);
  }
SWIGINTERN void SoActionMethodList___setitem__(SoActionMethodList *self,int const i,SoActionMethod *value){ self->set(i,value); }
SWIGINTERN SoActionMethod &SoActionMethodList___getitem__(SoActionMethodList *self,int const i){ return (*self)[i]; }
SWIGINTERN SoActionMethod SoActionMethodList_get(SoActionMethodList *self,int const i){ return (*self)[i]; }

static SoCallbackAction::Response
SoCallbackActionPythonCB(void * userdata,
                         SoCallbackAction * action,
                         const SoNode * node) {
  PyObject *func, *arglist;
  PyObject *result, *acCB, *pynode;
  int iresult = 0;

  acCB = SWIG_NewPointerObj((void *)action, SWIGTYPE_p_SoCallbackAction, 0);
  pynode = autocast_base((SoBase*)node);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OOO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB, pynode);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }
  else {
    iresult = PyInt_AsLong(result);
  }
  
  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_XDECREF(result);

  return (SoCallbackAction::Response)iresult;
}

static void
SoTrianglePythonCB(void * userdata, SoCallbackAction * action,
                   const SoPrimitiveVertex * v1,
                   const SoPrimitiveVertex * v2,
                   const SoPrimitiveVertex * v3)
{
  PyObject *func, *arglist;
  PyObject *result, *acCB;
  PyObject *vertex1, *vertex2, *vertex3;

  acCB = SWIG_NewPointerObj((void *) action, SWIGTYPE_p_SoCallbackAction, 0);
  vertex1 = SWIG_NewPointerObj((void *) v1, SWIGTYPE_p_SoPrimitiveVertex, 0);
  vertex2 = SWIG_NewPointerObj((void *) v2, SWIGTYPE_p_SoPrimitiveVertex, 0);
  vertex3 = SWIG_NewPointerObj((void *) v3, SWIGTYPE_p_SoPrimitiveVertex, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OOOOO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB, vertex1, vertex2, vertex3);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_DECREF(vertex1);
  Py_DECREF(vertex2);
  Py_DECREF(vertex3);
  Py_XDECREF(result);
}

static void
SoLineSegmentPythonCB(void * userdata, SoCallbackAction * action,
                const SoPrimitiveVertex * v1,
                const SoPrimitiveVertex * v2)
{
  PyObject *func, *arglist;
  PyObject *result, *acCB;
  PyObject *vertex1, *vertex2;

  acCB = SWIG_NewPointerObj((void *) action, SWIGTYPE_p_SoCallbackAction, 0);
  vertex1 = SWIG_NewPointerObj((void *) v1, SWIGTYPE_p_SoPrimitiveVertex, 0);
  vertex2 = SWIG_NewPointerObj((void *) v2, SWIGTYPE_p_SoPrimitiveVertex, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OOOO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB, vertex1, vertex2);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_DECREF(vertex1);
  Py_DECREF(vertex2);
  Py_XDECREF(result);
}

static void
SoPointPythonCB(void * userdata, SoCallbackAction * action, const SoPrimitiveVertex * v)
{
  PyObject *func, *arglist;
  PyObject *result, *acCB;
  PyObject *vertex;

  acCB = SWIG_NewPointerObj((void *) action, SWIGTYPE_p_SoCallbackAction, 0);
  vertex = SWIG_NewPointerObj((void *) v, SWIGTYPE_p_SoPrimitiveVertex, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OOO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB, vertex);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_DECREF(vertex);
  Py_XDECREF(result);
}

SWIGINTERN PyObject *SoFieldContainer_getFieldName__SWIG_1(SoFieldContainer *self,SoField *field){
        SbName name;
        if (!self->getFieldName(field, name)) {
            Py_INCREF(Py_None);
            return Py_None;
        }
    return Py_BuildValue("s", name.getString());
}

static void
sensorQueueChangedPythonCB(void * userdata)
{
  PyObject *func, *arglist;
  PyObject *result;

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(O)", PyTuple_GetItem((PyObject *)userdata, 1));

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }  
  Py_DECREF(arglist);
  Py_XDECREF(result);
}

SWIGINTERN void SoSensorManager_setChangedCallback__SWIG_1(SoSensorManager *self,PyObject *pyfunc,PyObject *data){
    self->setChangedCallback(sensorQueueChangedPythonCB, 
                             (void *)Py_BuildValue("(OO)", 
                                                   pyfunc, 
                                                   data ? data : Py_None));
  }
SWIGINTERN PyObject *SoSensorManager_isTimerSensorPending__SWIG_1(SoSensorManager *self){
    SbTime tm;
    if (!self->isTimerSensorPending(tm)) {
      Py_INCREF(Py_None);
      return Py_None;
    }
    SbTime * retTm = new SbTime(tm.getValue());
    return SWIG_NewPointerObj((void *)retTm, SWIGTYPE_p_SbTime, 1);
  }

#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}

SWIGINTERN void SoSFEnum_setValue__SWIG_2(SoSFEnum *self,SoSFEnum const *other){ *self = *other; }
SWIGINTERN void SoSFFloat_setValue__SWIG_1(SoSFFloat *self,SoSFFloat const *other){ *self = *other; }
SWIGINTERN void SoSFUShort_setValue__SWIG_1(SoSFUShort *self,SoSFUShort const *other){ *self = *other; }
SWIGINTERN void SoSFInt32_setValue__SWIG_1(SoSFInt32 *self,SoSFInt32 const *other){ *self = *other; }

static void
convert_SbVec3f_array(PyObject * input, float temp[3])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 3) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1)) && 
      PyNumber_Check(PySequence_GetItem(input, 2))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
    temp[2] = PyFloat_AsDouble(PySequence_GetItem(input, 2));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 3 floats");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec3f SbVec3f___add__(SbVec3f *self,SbVec3f const &u){ return *self + u; }
SWIGINTERN SbVec3f SbVec3f___sub__(SbVec3f *self,SbVec3f const &u){ return *self - u; }
SWIGINTERN SbVec3f SbVec3f___mul____SWIG_0(SbVec3f *self,float const d){ return *self * d; }
SWIGINTERN SbVec3f SbVec3f___mul____SWIG_1(SbVec3f *self,SbMatrix const &m){ SbVec3f res; m.multVecMatrix(*self,res); return res; }
SWIGINTERN SbVec3f SbVec3f___rmul__(SbVec3f *self,float const d){ return *self * d; }
SWIGINTERN SbVec3f SbVec3f___div__(SbVec3f *self,float const d){ return *self / d; }
SWIGINTERN SbVec3f SbVec3f___truediv__(SbVec3f *self,float const d){ return *self / d; }
SWIGINTERN int SbVec3f___eq__(SbVec3f *self,SbVec3f const &u){ return *self == u; }
SWIGINTERN int SbVec3f___nq__(SbVec3f *self,SbVec3f const &u){ return *self != u; }
SWIGINTERN float SbVec3f___getitem__(SbVec3f *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec3f___setitem__(SbVec3f *self,int i,float value){ (*self)[i] = value; }
SWIGINTERN SbColor SbColor___add__(SbColor *self,SbColor const &u){ return *self + u; }
SWIGINTERN SbColor SbColor___sub__(SbColor *self,SbColor const &u){ return *self - u; }
SWIGINTERN SbColor SbColor___mul__(SbColor *self,float const d){ return *self * d; }
SWIGINTERN SbColor SbColor___rmul__(SbColor *self,float const d){ return *self * d; }
SWIGINTERN SbColor SbColor___div__(SbColor *self,float const d){ return *self / d; }
SWIGINTERN int SbColor___eq__(SbColor *self,SbColor const &u){ return *self == u; }
SWIGINTERN int SbColor___nq__(SbColor *self,SbColor const &u){ return *self != u; }
SWIGINTERN float SbColor___getitem__(SbColor *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbColor___setitem__(SbColor *self,int i,float value){ (*self)[i] = value; }
SWIGINTERN void SoSFBool_setValue__SWIG_1(SoSFBool *self,SoSFBool const *other){ *self = *other; }
SWIGINTERN void SoSFImage_setValue__SWIG_2(SoSFImage *self,SbVec2s const &size,int const nc,PyObject *pixels){
    Py_ssize_t len = size[0] * size[1] * nc;
    unsigned char * image;



    PyObject *  b_pixels = pixels;
    if  (PyUnicode_Check(pixels)){
      b_pixels = PyUnicode_AsEncodedString(pixels, "utf-8", "Error ~");
    }
    PyBytes_AsStringAndSize(b_pixels, (char **)&image, &len);

    self->setValue(size, nc, image);
  }
SWIGINTERN void SoSFImage_setValue__SWIG_3(SoSFImage *self,SoSFImage const *other){ *self = *other; }
SWIGINTERN void SoSFString_setValue__SWIG_2(SoSFString *self,SoSFString const *other){ *self = *other; }
SWIGINTERN void SoSFColor_setValue__SWIG_4(SoSFColor *self,SoSFColor const *other){ *self = *other; }

static void
convert_SbVec3s_array(PyObject * input, short temp[3])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 3) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1)) &&
      PyNumber_Check(PySequence_GetItem(input, 2))) {
    temp[0] = PyInt_AsLong(PySequence_GetItem(input, 0));
    temp[1] = PyInt_AsLong(PySequence_GetItem(input, 1));
    temp[2] = PyInt_AsLong(PySequence_GetItem(input, 2));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 3 shorts");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec3s SbVec3s___add__(SbVec3s *self,SbVec3s const &u){ return *self + u; }
SWIGINTERN SbVec3s SbVec3s___sub__(SbVec3s *self,SbVec3s const &u){ return *self - u; }
SWIGINTERN SbVec3s SbVec3s___mul__(SbVec3s *self,double const d){ return *self * d; }
SWIGINTERN SbVec3s SbVec3s___rmul__(SbVec3s *self,double const d){ return *self * d; }
SWIGINTERN SbVec3s SbVec3s___div__(SbVec3s *self,double const d){ return *self / d; }
SWIGINTERN SbVec3s SbVec3s___truediv__(SbVec3s *self,double const d){ return *self / d; }
SWIGINTERN int SbVec3s___eq__(SbVec3s *self,SbVec3s const &u){ return *self == u; }
SWIGINTERN int SbVec3s___nq__(SbVec3s *self,SbVec3s const &u){ return *self != u; }
SWIGINTERN short SbVec3s___getitem__(SbVec3s *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec3s___setitem__(SbVec3s *self,int i,short value){ (*self)[i] = value; }
SWIGINTERN PyObject *SoCallbackAction_getMaterial__SWIG_0(SoCallbackAction *self,int const index=0){
    SbColor * ambient = new SbColor;
    SbColor * diffuse = new SbColor;
    SbColor * specular = new SbColor;
    SbColor * emission = new SbColor;
    float shininess, transparency;

    self->getMaterial(*ambient, *diffuse, *specular, *emission, shininess, transparency, index);
    
    return Py_BuildValue("(OOOOff)", 
                         SWIG_NewPointerObj(ambient, SWIGTYPE_p_SbColor, 1),
                         SWIG_NewPointerObj(diffuse, SWIGTYPE_p_SbColor, 1),
                         SWIG_NewPointerObj(specular, SWIGTYPE_p_SbColor, 1),
                         SWIG_NewPointerObj(emission, SWIGTYPE_p_SbColor, 1),
                         shininess,
                         transparency);
  }
SWIGINTERN void SoCallbackAction_addPreCallback__SWIG_1(SoCallbackAction *self,SoType const type,PyObject *pyfunc,PyObject *userdata){
    self->addPreCallback(type, SoCallbackActionPythonCB,
                         (void *)Py_BuildValue("(OO)",
                                               pyfunc,
                                               userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addPostCallback__SWIG_1(SoCallbackAction *self,SoType const type,PyObject *pyfunc,PyObject *userdata){
    self->addPostCallback(type, SoCallbackActionPythonCB,
                          (void *)Py_BuildValue("(OO)",
                                                pyfunc,
                                                userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addPreTailCallback__SWIG_1(SoCallbackAction *self,PyObject *pyfunc,PyObject *userdata){
    self->addPreTailCallback(SoCallbackActionPythonCB,
                             (void *)Py_BuildValue("(OO)",
                                                   pyfunc,
                                                   userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addPostTailCallback__SWIG_1(SoCallbackAction *self,PyObject *pyfunc,PyObject *userdata){
    self->addPostTailCallback(SoCallbackActionPythonCB,
                              (void *)Py_BuildValue("(OO)",
                                                    pyfunc,
                                                    userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addTriangleCallback__SWIG_1(SoCallbackAction *self,SoType const type,PyObject *pyfunc,PyObject *userdata){
    self->addTriangleCallback(type, SoTrianglePythonCB,
                              (void *)Py_BuildValue("(OO)",
                                                    pyfunc,
                                                    userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addLineSegmentCallback__SWIG_1(SoCallbackAction *self,SoType const type,PyObject *pyfunc,PyObject *userdata){
    self->addLineSegmentCallback(type, SoLineSegmentPythonCB,
                                 (void *)Py_BuildValue("(OO)",
                                                       pyfunc,
                                                       userdata ? userdata : Py_None));
  }
SWIGINTERN void SoCallbackAction_addPointCallback__SWIG_1(SoCallbackAction *self,SoType const type,PyObject *pyfunc,PyObject *userdata){
    self->addPointCallback(type, SoPointPythonCB,
                           (void *)Py_BuildValue("(OO)",
                                                 pyfunc,
                                                 userdata ? userdata : Py_None));
  }

static void
SoGLRenderPassPythonCB(void * userdata)
{
  PyObject *func, *arglist;
  PyObject *result;

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("O", PyTuple_GetItem((PyObject *)userdata, 1));

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_XDECREF(result);
}

static SoGLRenderAction::AbortCode
SoGLRenderAbortPythonCB(void * userdata)
{
  PyObject *func, *arglist;
  PyObject *result;
  SoGLRenderAction::AbortCode res;

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("O", PyTuple_GetItem((PyObject *)userdata, 1));

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  res = (SoGLRenderAction::AbortCode)PyInt_AsLong(result);

  Py_DECREF(arglist);
  Py_XDECREF(result);

  return res;
}

static void
SoGLPreRenderPythonCB(void * userdata, class SoGLRenderAction * action)
{
  PyObject *func, *arglist;
  PyObject *result, *acCB;

  acCB = SWIG_NewPointerObj((void *) action, SWIGTYPE_p_SoGLRenderAction, 1);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_XDECREF(result);
}

SWIGINTERN int SbViewportRegion___eq__(SbViewportRegion *self,SbViewportRegion const &u){ return *self == u; }
SWIGINTERN int SbViewportRegion___ne__(SbViewportRegion *self,SbViewportRegion const &u){ return !(*self == u ); }
SWIGINTERN void SoGLRenderAction_setPassCallback__SWIG_1(SoGLRenderAction *self,PyObject *pyfunc,PyObject *userdata){
    self->setPassCallback(SoGLRenderPassPythonCB,
                          (void *)Py_BuildValue("(OO)",
                                                pyfunc,
                                                userdata ? userdata : Py_None));
  }
SWIGINTERN void SoGLRenderAction_setAbortCallback__SWIG_1(SoGLRenderAction *self,PyObject *pyfunc,PyObject *userdata){
    self->setAbortCallback(SoGLRenderAbortPythonCB,
                           (void *)Py_BuildValue("(OO)",
                                                 pyfunc,
                                                 userdata ? userdata : Py_None));
  }
SWIGINTERN void SoGLRenderAction_addPreRenderCallback__SWIG_1(SoGLRenderAction *self,PyObject *pyfunc,PyObject *userdata){
    self->addPreRenderCallback(SoGLPreRenderPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     userdata ? userdata : Py_None));
  }
SWIGINTERN void SoGLRenderAction_removePreRenderCallback__SWIG_1(SoGLRenderAction *self,PyObject *pyfunc,PyObject *userdata){
    self->removePreRenderCallback(SoGLPreRenderPythonCB,
                                  (void *)Py_BuildValue("(OO)",
                                                        pyfunc,
                                                        userdata ? userdata : Py_None));
  }
SWIGINTERN SoGLRenderAction *SoGLRenderAction_constructFromAction(SoAction *action){
    return (SoGLRenderAction*) action;
  }
SWIGINTERN int SbBox3f___eq__(SbBox3f *self,SbBox3f const &u){ return *self == u; }
SWIGINTERN int SbBox3f___ne__(SbBox3f *self,SbBox3f const &u){ return *self != u; }

static void
convert_SbMat_array(PyObject * input, SbMat temp)
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 0)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 1)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 2)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 3)) == 4)) {    
    int i,j;
    for (i=0; i < 4; i++) {
      for (j=0; j < 4; j++) {
        PyObject * oij = PySequence_GetItem(PySequence_GetItem(input, i), j);
        if (!PyNumber_Check(oij)) {
          PyErr_SetString(PyExc_TypeError,
                          "sequence must contain 4 sequences where every sequence contains 4 floats");
          PyErr_Print();
          return;
        }
        temp[i][j] = PyFloat_AsDouble(oij);
        Py_DECREF(oij);
      }
    }
  } else {
    PyErr_SetString(PyExc_TypeError,
                    "sequence must contain 4 sequences where every sequence contains 4 floats");
    PyErr_Print();
  }
}

SWIGINTERN PyObject *SbMatrix_getTransform__SWIG_1(SbMatrix *self){
    SbVec3f * t = new SbVec3f;
    SbVec3f * s = new SbVec3f;
    SbRotation * r = new SbRotation;
    SbRotation * so = new SbRotation;

    self->getTransform(*t, *r, *s, *so);

    return Py_BuildValue("(OOOO)",
                         SWIG_NewPointerObj((void *)t, SWIGTYPE_p_SbVec3f, 1),
                         SWIG_NewPointerObj((void *)r, SWIGTYPE_p_SbRotation, 1),
                         SWIG_NewPointerObj((void *)s, SWIGTYPE_p_SbVec3f, 1),
                         SWIG_NewPointerObj((void *)so, SWIGTYPE_p_SbRotation, 1));
  }
SWIGINTERN PyObject *SbMatrix_getTransform__SWIG_2(SbMatrix *self,SbVec3f &center){
    SbVec3f * t = new SbVec3f;
    SbVec3f * s = new SbVec3f;
    SbRotation * r = new SbRotation;
    SbRotation * so = new SbRotation;

    self->getTransform(*t, *r, *s, *so, center);

    return Py_BuildValue("(OOOO)",
                         SWIG_NewPointerObj((void *)t, SWIGTYPE_p_SbVec3f, 1),
                         SWIG_NewPointerObj((void *)r, SWIGTYPE_p_SbRotation, 1),
                         SWIG_NewPointerObj((void *)s, SWIGTYPE_p_SbVec3f, 1),
                         SWIG_NewPointerObj((void *)so, SWIGTYPE_p_SbRotation, 1));
  }
SWIGINTERN SbMatrix SbMatrix___mul____SWIG_0(SbMatrix *self,SbMatrix const &u){ return *self * u; }
SWIGINTERN SbVec3f SbMatrix___mul____SWIG_1(SbMatrix *self,SbVec3f const &u){ SbVec3f res; self->multMatrixVec(u, res); return res; }
SWIGINTERN SbVec3f SbMatrix___rmul__(SbMatrix *self,SbVec3f const &u){ SbVec3f res; self->multVecMatrix(u, res); return res; }
SWIGINTERN int SbMatrix___eq__(SbMatrix *self,SbMatrix const &u){ return *self == u; }
SWIGINTERN int SbMatrix___ne__(SbMatrix *self,SbMatrix const &u){ return *self != u; }
SWIGINTERN float const *SbMatrix___getitem__(SbMatrix *self,int i){ return (self->getValue())[i]; }
SWIGINTERN int SbXfBox3f___eq__(SbXfBox3f *self,SbXfBox3f const &u){ return *self == u; }
SWIGINTERN int SbXfBox3f___ne__(SbXfBox3f *self,SbXfBox3f const &u){ return *self != u; }

static void
convert_SbVec4f_array(PyObject * input, float temp[4])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 4) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1)) && 
      PyNumber_Check(PySequence_GetItem(input, 2)) && 
      PyNumber_Check(PySequence_GetItem(input, 3))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
    temp[2] = PyFloat_AsDouble(PySequence_GetItem(input, 2));
    temp[3] = PyFloat_AsDouble(PySequence_GetItem(input, 3));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 4 floats");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec4f SbVec4f___add__(SbVec4f *self,SbVec4f const &u){ return *self + u; }
SWIGINTERN SbVec4f SbVec4f___sub__(SbVec4f *self,SbVec4f const &u){ return *self - u; }
SWIGINTERN SbVec4f SbVec4f___mul____SWIG_0(SbVec4f *self,float const d){ return *self * d; }
SWIGINTERN SbVec4f SbVec4f___mul____SWIG_1(SbVec4f *self,SbMatrix const &m){ SbVec4f res; m.multVecMatrix(*self,res); return res; }
SWIGINTERN SbVec4f SbVec4f___rmul__(SbVec4f *self,float const d){ return *self * d; }
SWIGINTERN SbVec4f SbVec4f___div__(SbVec4f *self,float const d){ return *self / d; }
SWIGINTERN SbVec4f SbVec4f___truediv__(SbVec4f *self,float const d){ return *self / d; }
SWIGINTERN int SbVec4f___eq__(SbVec4f *self,SbVec4f const &u){ return *self == u; }
SWIGINTERN int SbVec4f___nq__(SbVec4f *self,SbVec4f const &u){ return *self != u; }
SWIGINTERN float SbVec4f___getitem__(SbVec4f *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec4f___setitem__(SbVec4f *self,int i,float value){ (*self)[i] = value; }
SWIGINTERN SbRotation SbRotation___mul____SWIG_0(SbRotation *self,SbRotation const &u){ return *self * u; }
SWIGINTERN SbRotation SbRotation___mul____SWIG_1(SbRotation *self,double const d){ SbRotation res(*self); return (res *= d); }
SWIGINTERN SbVec3f SbRotation___mul____SWIG_2(SbRotation *self,SbVec3f const &v){ SbVec3f res; self->multVec(v, res); return res; }
SWIGINTERN int SbRotation___eq__(SbRotation *self,SbRotation const &u){ return *self == u; }
SWIGINTERN int SbRotation___nq__(SbRotation *self,SbRotation const &u){ return *self != u; }

static SoCallbackAction::Response
SoIntersectionVisitationPythonCB(void * closure, 
                                 const SoPath * where)
{
  PyObject *func, *arglist;
  PyObject *result, *path;
  int iresult = 0;

  path = SWIG_NewPointerObj((void *) where, SWIGTYPE_p_SoPath, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)closure, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)closure, 1), path);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }
  else {
    iresult = PyInt_AsLong(result);
  }
  
  Py_DECREF(arglist);
  Py_DECREF(path);
  Py_XDECREF(result);

  return (SoCallbackAction::Response)iresult;
}

static SbBool
SoIntersectionFilterPythonCB(void * closure,
                             const SoPath * p1,
                             const SoPath * p2)
{   
  PyObject *func, *arglist;
  PyObject *result, *path1, *path2;
  int iresult = 0;

  path1 = SWIG_NewPointerObj((void *) p1, SWIGTYPE_p_SoPath, 0);
  path2 = SWIG_NewPointerObj((void *) p2, SWIGTYPE_p_SoPath, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)closure, 0);
  arglist = Py_BuildValue("(OOO)", PyTuple_GetItem((PyObject *)closure, 1), path1, path2);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }
  else {
    iresult = PyInt_AsLong(result);
  }
  
  Py_DECREF(arglist);
  Py_DECREF(path1);
  Py_DECREF(path2);
  Py_XDECREF(result);

  return (SbBool)iresult;
}

static SoIntersectionDetectionAction::Resp
SoIntersectionPythonCB(void * closure, 
                       const SoIntersectingPrimitive * p1, 
                       const SoIntersectingPrimitive * p2)
{
  PyObject *func, *arglist;
  PyObject *result, *primitive1, *primitive2;
  int iresult = 0;

  primitive1 = SWIG_NewPointerObj((void *) p1, SWIGTYPE_p_SoIntersectingPrimitive, 0);
  primitive2 = SWIG_NewPointerObj((void *) p2, SWIGTYPE_p_SoIntersectingPrimitive, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)closure, 0);
  arglist = Py_BuildValue("(OOO)", PyTuple_GetItem((PyObject *)closure, 1), primitive1, primitive2);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }
  else {
    iresult = PyInt_AsLong(result);
  }
  
  Py_DECREF(arglist);
  Py_DECREF(primitive1);
  Py_DECREF(primitive2);
  Py_XDECREF(result);

  return (SoIntersectionDetectionAction::Resp)iresult;
}

SWIGINTERN void SoIntersectionDetectionAction_addVisitationCallback__SWIG_1(SoIntersectionDetectionAction *self,SoType type,PyObject *pyfunc,PyObject *closure){
    self->addVisitationCallback(type, SoIntersectionVisitationPythonCB,
                                (void *)Py_BuildValue("(OO)",
                                                      pyfunc,
                                                      closure ? closure : Py_None));
  }
SWIGINTERN void SoIntersectionDetectionAction_removeVisitationCallback__SWIG_1(SoIntersectionDetectionAction *self,SoType type,PyObject *pyfunc,PyObject *closure){
    self->removeVisitationCallback(type, SoIntersectionVisitationPythonCB,
                                   (void *)Py_BuildValue("(OO)",
                                                         pyfunc,
                                                         closure ? closure : Py_None));
  }
SWIGINTERN void SoIntersectionDetectionAction_setFilterCallback__SWIG_2(SoIntersectionDetectionAction *self,PyObject *pyfunc,PyObject *closure=NULL){
    self->setFilterCallback(SoIntersectionFilterPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  closure ? closure : Py_None));
  }
SWIGINTERN void SoIntersectionDetectionAction_addIntersectionCallback__SWIG_2(SoIntersectionDetectionAction *self,PyObject *pyfunc,PyObject *closure=NULL){
    self->addIntersectionCallback(SoIntersectionPythonCB,
                                  (void *)Py_BuildValue("(OO)",
                                                        pyfunc,
                                                        closure ? closure : Py_None));
  }
SWIGINTERN void SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_2(SoIntersectionDetectionAction *self,PyObject *pyfunc,PyObject *closure=NULL){
    self->removeIntersectionCallback(SoIntersectionPythonCB,
                                     (void *)Py_BuildValue("(OO)",
                                                           pyfunc,
                                                           closure ? closure : Py_None));
  }

static void
SoDraggerPythonCB(void * data, SoDragger * dragger)
{
  PyObject *func, *arglist;
  PyObject *result, *dragCB;

  dragCB = SWIG_NewPointerObj((void *) dragger, SWIGTYPE_p_SoDragger, 0);

  /* the first item in the data sequence is the python callback
   * function; the second is the supplied data python object */
  func = PyTuple_GetItem((PyObject *)data, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)data, 1), dragCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(dragCB);
  Py_XDECREF(result);
}

SWIGINTERN void SoSFNode_setValue__SWIG_1(SoSFNode *self,SoSFNode const *other){ *self = *other; }
SWIGINTERN void SoSFName_setValue__SWIG_2(SoSFName *self,SoSFName const *other){ *self = *other; }
SWIGINTERN SbName const &SoMFName___getitem__(SoMFName *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFName___setitem__(SoMFName *self,int i,SbName const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFName_setValue__SWIG_2(SoMFName *self,SoMFName const *other){ *self = *other; }
SWIGINTERN SbName const *SoMFName___getValuesHelper____SWIG_0(SoMFName *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN int SoNodeKitPath___eq__(SoNodeKitPath *self,SoNodeKitPath const &u){ return *self == u; }
SWIGINTERN int SoNodeKitPath___nq__(SoNodeKitPath *self,SoNodeKitPath const &u){ return !(*self == u); }

static void
SoSensorPythonCB(void * data, SoSensor * sensor)
{
  PyGILState_STATE gil = PyGILState_Ensure();
  swig_type_info * swig_type = 0;
  const char * sensor_cast_name = NULL;
  PyObject * func, * arglist;
  PyObject * result, * pysensor;

  /* the first item in the data sequence is the python callback
   * function; the second item is the supplied data python object; the
   * third item contains the sensor type that we should create */
#ifdef PY_2
    sensor_cast_name = PyString_AsString(PyTuple_GetItem((PyObject *)data, 2));
#else
    PyObject* item = PyTuple_GetItem((PyObject *)data, 2);
    if (PyUnicode_Check(item)){
    sensor_cast_name = PyUnicode_AsUTF8(item);
    }
    else if (PyBytes_Check(item)){
      sensor_cast_name = PyBytes_AsString(item);
    }

#endif
  if (!sensor_cast_name){
    PyErr_SetString(PyExc_TypeError, "Sensor type query failed.");
    return;
  }
  else if (!(swig_type = SWIG_TypeQuery(sensor_cast_name))) {
    PyErr_SetString(PyExc_TypeError, "Sensor type query failed.");
    return;
  }
  pysensor = SWIG_NewPointerObj((void *)sensor, swig_type, 0);

  func = PyTuple_GetItem((PyObject *)data, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)data, 1), pysensor);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(pysensor);
  Py_XDECREF(result);
  
  PyGILState_Release(gil);
}


static void
convert_SbVec3d_array(PyObject *input, double temp[3])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 3) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1)) && 
      PyNumber_Check(PySequence_GetItem(input, 2))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
    temp[2] = PyFloat_AsDouble(PySequence_GetItem(input, 2));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 3 doubles");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec3d SbVec3d___add__(SbVec3d *self,SbVec3d const &u){ return *self + u; }
SWIGINTERN SbVec3d SbVec3d___sub__(SbVec3d *self,SbVec3d const &u){ return *self - u; }
SWIGINTERN SbVec3d SbVec3d___mul____SWIG_0(SbVec3d *self,double const d){ return *self * d; }
SWIGINTERN SbVec3d SbVec3d___mul____SWIG_1(SbVec3d *self,SbDPMatrix const &m){ SbVec3d res; m.multVecMatrix(*self,res); return res; }
SWIGINTERN SbVec3d SbVec3d___rmul__(SbVec3d *self,double const d){ return *self * d; }
SWIGINTERN SbVec3d SbVec3d___div__(SbVec3d *self,double const d){ return *self / d; }
SWIGINTERN SbVec3d SbVec3d___truediv__(SbVec3d *self,double const d){ return *self / d; }
SWIGINTERN int SbVec3d___eq__(SbVec3d *self,SbVec3d const &u){ return *self == u; }
SWIGINTERN int SbVec3d___nq__(SbVec3d *self,SbVec3d const &u){ return *self != u; }
SWIGINTERN double SbVec3d___getitem__(SbVec3d *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec3d___setitem__(SbVec3d *self,int i,double value){ (*self)[i] = value; }
SWIGINTERN PyObject *SbViewVolume_projectPointToLine(SbViewVolume *self,SbVec2f const &pt){
    SbVec3f * line0 = new SbVec3f;
    SbVec3f * line1 = new SbVec3f;

    self->projectPointToLine(pt, *line0, *line1);

    return Py_BuildValue("(OO)",
                         SWIG_NewPointerObj((void *)line0, SWIGTYPE_p_SbVec3f, 1),
                         SWIG_NewPointerObj((void *)line1, SWIGTYPE_p_SbVec3f, 1));
  }
SWIGINTERN PyObject *SbViewVolume_projectToScreen(SbViewVolume *self,SbVec3f const &src){
    SbVec3f * dst = new SbVec3f;

    self->projectToScreen(src, *dst);

    return SWIG_NewPointerObj((void *)dst, SWIGTYPE_p_SbVec3f, 1);
  }
SWIGINTERN void SoSFVec3f_setValue__SWIG_3(SoSFVec3f *self,SoSFVec3f const *other){ *self = *other; }
SWIGINTERN void SoDragger_addStartCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->addStartCallback(SoDraggerPythonCB,
                           (void *)Py_BuildValue("(OO)", 
                                                 pyfunc, 
                                                 data ? data : Py_None));
  }
SWIGINTERN void SoDragger_removeStartCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->removeStartCallback(SoDraggerPythonCB, 
                              (void *)Py_BuildValue("(OO)", 
                                                    pyfunc, 
                                                    data ? data : Py_None));
  }
SWIGINTERN void SoDragger_addMotionCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->addMotionCallback(SoDraggerPythonCB,
                            (void *)Py_BuildValue("(OO)", 
                                                  pyfunc, 
                                                  data ? data : Py_None));
  }
SWIGINTERN void SoDragger_removeMotionCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->removeMotionCallback(SoDraggerPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     data ? data : Py_None));
  }
SWIGINTERN void SoDragger_addFinishCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->addFinishCallback(SoDraggerPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  data ? data : Py_None));
  }
SWIGINTERN void SoDragger_removeFinishCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->removeFinishCallback(SoDraggerPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     data ? data : Py_None));
  }
SWIGINTERN void SoDragger_addValueChangedCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->addValueChangedCallback(SoDraggerPythonCB,
                                  (void *)Py_BuildValue("(OO)",
                                                        pyfunc,
                                                        data ? data : Py_None));
  }
SWIGINTERN void SoDragger_removeValueChangedCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->removeValueChangedCallback(SoDraggerPythonCB,
                                     (void *)Py_BuildValue("(OO)",
                                                           pyfunc,
                                                           data ? data : Py_None));
  }
SWIGINTERN void SoDragger_addOtherEventCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->addOtherEventCallback(SoDraggerPythonCB,
                                (void *)Py_BuildValue("(OO)",
                                                      pyfunc,
                                                      data ? data : Py_None));
  }
SWIGINTERN void SoDragger_removeOtherEventCallback__SWIG_2(SoDragger *self,PyObject *pyfunc,PyObject *data=NULL){
    self->removeOtherEventCallback(SoDraggerPythonCB,
                                   (void *)Py_BuildValue("(OO)",
                                                         pyfunc,
                                                         data ? data : Py_None));
  }
SWIGINTERN void SoSFRotation_setValue__SWIG_4(SoSFRotation *self,SoSFRotation const *other){ *self = *other; }
SWIGINTERN void SoSFVec2f_setValue__SWIG_3(SoSFVec2f *self,SoSFVec2f const *other){ *self = *other; }
SWIGINTERN int SbPlane___eq__(SbPlane *self,SbPlane const &u){ return *self == u; }
SWIGINTERN int SbPlane___ne__(SbPlane *self,SbPlane const &u){ return *self != u; }
SWIGINTERN PyObject *SbPlane_intersect__SWIG_0(SbPlane *self,SbLine const &l){
        SbVec3f * point = new SbVec3f;
        self->intersect(l, *point);
        return SWIG_NewPointerObj((void *)point, SWIGTYPE_p_SbVec3f, 1);
    }
SWIGINTERN PyObject *SbPlane_intersect__SWIG_1(SbPlane *self,SbPlane const &pl){
        SbLine * line = new SbLine;
        self->intersect(pl, *line);
        return SWIG_NewPointerObj((void *)line, SWIGTYPE_p_SbLine, 1);
    }
SWIGINTERN SbColor4f SbColor4f___add__(SbColor4f *self,SbColor4f const &u){ return *self + u; }
SWIGINTERN SbColor4f SbColor4f___sub__(SbColor4f *self,SbColor4f const &u){ return *self - u; }
SWIGINTERN SbColor4f SbColor4f___mul__(SbColor4f *self,float const d){ return *self * d; }
SWIGINTERN SbColor4f SbColor4f___rmul__(SbColor4f *self,float const d){ return *self * d; }
SWIGINTERN SbColor4f SbColor4f___div__(SbColor4f *self,float const d){ return *self / d; }
SWIGINTERN int SbColor4f___eq__(SbColor4f *self,SbColor4f const &u){ return *self == u; }
SWIGINTERN int SbColor4f___nq__(SbColor4f *self,SbColor4f const &u){ return *self != u; }
SWIGINTERN float SbColor4f___getitem__(SbColor4f *self,int i){ return (self->getValue())[i]; }

static void
convert_SoMFBool_array(PyObject * input, int len, SbBool * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (SbBool) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
      free(temp);       
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN void SoMFBool_setValue__SWIG_1(SoMFBool *self,SoMFBool const *other){ *self = *other; }
SWIGINTERN SbBool const SoMFBool___getitem__(SoMFBool *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFBool___setitem__(SoMFBool *self,int i,SbBool value){ self->set1Value(i, value); }
SWIGINTERN SbBool const *SoMFBool___getValuesHelper____SWIG_0(SoMFBool *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFEnum_array(PyObject * input, int len, int * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input,i);
    if (PyNumber_Check(oi)) {
      temp[i] = (int) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
      free(temp);       
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN int const SoMFEnum___getitem__(SoMFEnum *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFEnum___setitem__(SoMFEnum *self,int i,int value){ self->set1Value(i, value); }
SWIGINTERN void SoMFEnum_setValue__SWIG_2(SoMFEnum *self,SoMFEnum const *other){ *self = *other; }
SWIGINTERN int const *SoMFEnum___getValuesHelper____SWIG_0(SoMFEnum *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFFloat_array(PyObject * input, int len, float * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (float) PyFloat_AsDouble(oi);
    } else {
      PyErr_SetString(PyExc_ValueError, "Sequence elements must be floats");
      Py_DECREF(oi);
      free(temp);       
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN float const SoMFFloat___getitem__(SoMFFloat *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFFloat___setitem__(SoMFFloat *self,int i,float value){ self->set1Value(i, value); }
SWIGINTERN void SoMFFloat_setValue__SWIG_1(SoMFFloat *self,SoMFFloat const *other){ *self = *other; }
SWIGINTERN float const *SoMFFloat___getValuesHelper____SWIG_0(SoMFFloat *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFVec3f_array(PyObject * input, int len, float temp[][3])
{
  int i,j;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    for (j=0; j<3; j++) {
      PyObject * oj = PySequence_GetItem(oi, j);
      if (PyNumber_Check(oj)) {
        temp[i][j] = (float) PyFloat_AsDouble(oj);
      } else {
        PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
        free(temp);       
        Py_DECREF(oi);
        Py_DECREF(oj);
        return;
      }
      Py_DECREF(oj);
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN SbVec3f const &SoMFVec3f___getitem__(SoMFVec3f *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFVec3f___setitem__(SoMFVec3f *self,int i,SbVec3f const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFVec3f_setValue__SWIG_3(SoMFVec3f *self,SoMFVec3f const *other){ *self = *other; }
SWIGINTERN SbVec3f const *SoMFVec3f___getValuesHelper____SWIG_0(SoMFVec3f *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SbString const &SoMFString___getitem__(SoMFString *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFString___setitem__(SoMFString *self,int i,SbString const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFString_setValue__SWIG_2(SoMFString *self,SoMFString const *other){ *self = *other; }
SWIGINTERN SbString const *SoMFString___getValuesHelper____SWIG_0(SoMFString *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFVec2f_array(PyObject * input, int len, float temp[][2])
{
  int i,j;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    for (j=0; j<2; j++) {
      PyObject * oj = PySequence_GetItem(oi, j);
      if (PyNumber_Check(oj)) {
        temp[i][j] = (float) PyFloat_AsDouble(oj);
      } else {
        PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
        free(temp);       
        Py_DECREF(oi);
        Py_DECREF(oj);
        return;
      }
      Py_DECREF(oj);
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN SbVec2f const &SoMFVec2f___getitem__(SoMFVec2f *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFVec2f___setitem__(SoMFVec2f *self,int i,SbVec2f const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFVec2f_setValue__SWIG_3(SoMFVec2f *self,SoMFVec2f const *other){ *self = *other; }
SWIGINTERN SbVec2f const *SoMFVec2f___getValuesHelper____SWIG_0(SoMFVec2f *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFVec4f_array(PyObject * input, int len, float temp[][4])
{
  int i,j;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    for (j=0; j<4; j++) {
      PyObject * oj = PySequence_GetItem(oi, j);
      if (PyNumber_Check(oj)) {
        temp[i][j] = (float) PyFloat_AsDouble(oj);
      } else {
        PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
        free(temp);
        Py_DECREF(oi);
        Py_DECREF(oj);
        return;
      }
      Py_DECREF(oj);
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN SbVec4f const &SoMFVec4f___getitem__(SoMFVec4f *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFVec4f___setitem__(SoMFVec4f *self,int i,SbVec4f const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFVec4f_setValue__SWIG_3(SoMFVec4f *self,SoMFVec4f const *other){ *self = *other; }
SWIGINTERN SbVec4f const *SoMFVec4f___getValuesHelper____SWIG_0(SoMFVec4f *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SbRotation const &SoMFRotation___getitem__(SoMFRotation *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFRotation___setitem__(SoMFRotation *self,int i,SbRotation const &value){ self->set1Value(i, value); }
SWIGINTERN SbRotation const *SoMFRotation___getValuesHelper____SWIG_0(SoMFRotation *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN void SoMFRotation_setValue__SWIG_4(SoMFRotation *self,SoMFRotation const *other){ *self = *other; }
SWIGINTERN SbMatrix const &SoMFMatrix___getitem__(SoMFMatrix *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFMatrix___setitem__(SoMFMatrix *self,int i,SbMatrix const &value){ self->set1Value(i, value); }
SWIGINTERN SbMatrix const *SoMFMatrix___getValuesHelper____SWIG_0(SoMFMatrix *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN void SoMFMatrix_setValue__SWIG_2(SoMFMatrix *self,SoMFMatrix const *other){ *self = *other; }
SWIGINTERN void SoSFPath_setValue__SWIG_1(SoSFPath *self,SoSFPath const *other){ *self = *other; }
SWIGINTERN void SoSFTrigger_setValue__SWIG_1(SoSFTrigger *self,SoSFTrigger const *other){ *self = *other; }
SWIGINTERN void SoSFShort_setValue__SWIG_1(SoSFShort *self,SoSFShort const *other){ *self = *other; }
SWIGINTERN void SoSFTime_setValue__SWIG_1(SoSFTime *self,SbTime &other){ *self = other; }
SWIGINTERN void SoSFTime_setValue__SWIG_2(SoSFTime *self,SoSFTime const *other){ *self = *other; }
SWIGINTERN int SbBox2s___eq__(SbBox2s *self,SbBox2s const &u){ return *self == u; }
SWIGINTERN int SbBox2s___ne__(SbBox2s *self,SbBox2s const &u){ return *self != u; }
SWIGINTERN int SbBox2f___eq__(SbBox2f *self,SbBox2f const &u){ return *self == u; }
SWIGINTERN int SbBox2f___ne__(SbBox2f *self,SbBox2f const &u){ return *self != u; }

static void
convert_SbVec2d_array(PyObject *input, double temp[2])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 2) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 2 floats");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec2d SbVec2d___add__(SbVec2d *self,SbVec2d const &u){ return *self + u; }
SWIGINTERN SbVec2d SbVec2d___sub__(SbVec2d *self,SbVec2d const &u){ return *self - u; }
SWIGINTERN SbVec2d SbVec2d___mul__(SbVec2d *self,float const d){ return *self * d; }
SWIGINTERN SbVec2d SbVec2d___rmul__(SbVec2d *self,float const d){ return *self * d; }
SWIGINTERN SbVec2d SbVec2d___div__(SbVec2d *self,float const d){ return *self / d; }
SWIGINTERN SbVec2d SbVec2d___truediv__(SbVec2d *self,float const d){ return *self / d; }
SWIGINTERN int SbVec2d___eq__(SbVec2d *self,SbVec2d const &u){ return *self == u; }
SWIGINTERN int SbVec2d___nq__(SbVec2d *self,SbVec2d const &u){ return *self != u; }
SWIGINTERN double SbVec2d___getitem__(SbVec2d *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec2d___setitem__(SbVec2d *self,int i,double value){ (*self)[i] = value; }
SWIGINTERN int SbBox2d___eq__(SbBox2d *self,SbBox2d const &u){ return *self == u; }
SWIGINTERN int SbBox2d___ne__(SbBox2d *self,SbBox2d const &u){ return *self != u; }
SWIGINTERN SbBox2d &SbBox2d_setValue(SbBox2d *self,SbBox2d const &u){
    self->setBounds(u.getMin(), u.getMax());
    return *self;
  }
SWIGINTERN int SbBox3s___eq__(SbBox3s *self,SbBox3s const &u){ return *self == u; }
SWIGINTERN int SbBox3s___ne__(SbBox3s *self,SbBox3s const &u){ return *self != u; }
SWIGINTERN void SoSFEngine_setValue__SWIG_1(SoSFEngine *self,SoSFEngine const *other){ *self = *other; }
SWIGINTERN void SoSFImage3_setValue__SWIG_1(SoSFImage3 *self,SbVec3s const &size,int const nc,PyObject *pixels){
    Py_ssize_t len = size[0] * size[1] * size[2] * nc;
    unsigned char * image;



    PyObject *  b_pixels = pixels;
    if  (PyUnicode_Check(pixels)){
      b_pixels = PyUnicode_AsEncodedString(pixels, "utf-8", "Error ~");
    }
    PyBytes_AsStringAndSize(b_pixels, (char **)&image, &len);

    self->setValue(size, nc, image);
  }
SWIGINTERN void SoSFImage3_setValue__SWIG_2(SoSFImage3 *self,SoSFImage3 const *other){ *self = *other; }
SWIGINTERN void SoSFMatrix_setValue__SWIG_2(SoSFMatrix *self,SoSFMatrix const *other){ *self = *other; }
SWIGINTERN void SoSFPlane_setValue__SWIG_1(SoSFPlane *self,SoSFPlane const *other){ *self = *other; }
SWIGINTERN void SoSFUInt32_setValue__SWIG_1(SoSFUInt32 *self,SoSFUInt32 const *other){ *self = *other; }

SWIGINTERN int
SWIG_AsVal_signed_SS_char (PyObject * obj, signed char *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SCHAR_MIN || v > SCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< signed char >(v);
    }
  }  
  return res;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}

SWIGINTERN void SoSFVec4f_setValue__SWIG_3(SoSFVec4f *self,SoSFVec4f const *other){ *self = *other; }

static void
convert_SbVec4d_array(PyObject * input, double temp[4])
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 4) &&
      PyNumber_Check(PySequence_GetItem(input, 0)) && 
      PyNumber_Check(PySequence_GetItem(input, 1)) && 
      PyNumber_Check(PySequence_GetItem(input, 2)) && 
      PyNumber_Check(PySequence_GetItem(input, 3))) {
    temp[0] = PyFloat_AsDouble(PySequence_GetItem(input, 0));
    temp[1] = PyFloat_AsDouble(PySequence_GetItem(input, 1));
    temp[2] = PyFloat_AsDouble(PySequence_GetItem(input, 2));
    temp[3] = PyFloat_AsDouble(PySequence_GetItem(input, 3));
  } else {
    PyErr_SetString(PyExc_TypeError, "expected a sequence with 4 floats");
    PyErr_Print();
  } 
}

SWIGINTERN SbVec4d SbVec4d___add__(SbVec4d *self,SbVec4d const &u){ return *self + u; }
SWIGINTERN SbVec4d SbVec4d___sub__(SbVec4d *self,SbVec4d const &u){ return *self - u; }
SWIGINTERN SbVec4d SbVec4d___mul____SWIG_0(SbVec4d *self,double const d){ return *self * d; }
SWIGINTERN SbVec4d SbVec4d___mul____SWIG_1(SbVec4d *self,SbDPMatrix const &m){ SbVec4d res; m.multVecMatrix(*self,res); return res; }
SWIGINTERN SbVec4d SbVec4d___rmul__(SbVec4d *self,double const d){ return *self * d; }
SWIGINTERN SbVec4d SbVec4d___div__(SbVec4d *self,double const d){ return *self / d; }
SWIGINTERN SbVec4d SbVec4d___truediv__(SbVec4d *self,double const d){ return *self / d; }
SWIGINTERN int SbVec4d___eq__(SbVec4d *self,SbVec4d const &u){ return *self == u; }
SWIGINTERN int SbVec4d___nq__(SbVec4d *self,SbVec4d const &u){ return *self != u; }
SWIGINTERN double SbVec4d___getitem__(SbVec4d *self,int i){ return (self->getValue())[i]; }
SWIGINTERN void SbVec4d___setitem__(SbVec4d *self,int i,double value){ (*self)[i] = value; }
SWIGINTERN SbColor const &SoMFColor___getitem__(SoMFColor *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFColor___setitem____SWIG_0(SoMFColor *self,int i,SbColor const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFColor___setitem____SWIG_1(SoMFColor *self,int i,float const rgb[3]){ self->set1Value(i, rgb); }
SWIGINTERN void SoMFColor_setValue__SWIG_4(SoMFColor *self,SoMFColor const *other){ *self = *other; }
SWIGINTERN SbColor const *SoMFColor___getValuesHelper____SWIG_0(SoMFColor *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SoEngine const *SoMFEngine___getitem__(SoMFEngine *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFEngine___setitem__(SoMFEngine *self,int i,SoEngine *value){ self->set1Value(i, value); }
SWIGINTERN void SoMFEngine_setValue__SWIG_1(SoMFEngine *self,SoMFEngine const *other){ *self = *other; }
SWIGINTERN SoEngine const **SoMFEngine___getValuesHelper____SWIG_0(SoMFEngine *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFInt32_array(PyObject * input, int len, int32_t * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (int32_t) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
      free(temp);
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN int32_t const SoMFInt32___getitem__(SoMFInt32 *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFInt32___setitem__(SoMFInt32 *self,int i,int32_t value){ self->set1Value(i, value); }
SWIGINTERN void SoMFInt32_setValue__SWIG_1(SoMFInt32 *self,SoMFInt32 const *other){ *self = *other; }
SWIGINTERN int32_t const *SoMFInt32___getValuesHelper____SWIG_0(SoMFInt32 *self,int32_t &len,int32_t i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SoNode const *SoMFNode___getitem__(SoMFNode *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFNode___setitem__(SoMFNode *self,int i,SoNode *value){ self->set1Value(i, value); }
SWIGINTERN void SoMFNode_setValue__SWIG_1(SoMFNode *self,SoMFNode const *other){ *self = *other; }
SWIGINTERN SoNode const **SoMFNode___getValuesHelper____SWIG_0(SoMFNode *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SoPath const *SoMFPath___getitem__(SoMFPath *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFPath___setitem__(SoMFPath *self,int i,SoPath *value){ self->set1Value(i, value); }
SWIGINTERN void SoMFPath_setValue__SWIG_1(SoMFPath *self,SoMFPath const *other){ *self = *other; }
SWIGINTERN SoPath const **SoMFPath___getValuesHelper____SWIG_0(SoMFPath *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SbPlane const &SoMFPlane___getitem__(SoMFPlane *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFPlane___setitem__(SoMFPlane *self,int i,SbPlane const &value){ self->set1Value(i, value); }
SWIGINTERN SbPlane const *SoMFPlane___getValuesHelper____SWIG_0(SoMFPlane *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN void SoMFPlane_setValue__SWIG_1(SoMFPlane *self,SoMFPlane const *other){ *self = *other; }

static void
convert_SoMFShort_array(PyObject * input, int len, short * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (short) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
      free(temp);       
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN short const SoMFShort___getitem__(SoMFShort *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFShort___setitem__(SoMFShort *self,int i,short value){ self->set1Value(i, value); }
SWIGINTERN void SoMFShort_setValue__SWIG_1(SoMFShort *self,SoMFShort const *other){ *self = *other; }
SWIGINTERN short const *SoMFShort___getValuesHelper____SWIG_0(SoMFShort *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN SbTime const &SoMFTime___getitem__(SoMFTime *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFTime___setitem__(SoMFTime *self,int i,SbTime const &value){ self->set1Value(i, value); }
SWIGINTERN SbTime const *SoMFTime___getValuesHelper____SWIG_0(SoMFTime *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN void SoMFTime_setValue__SWIG_1(SoMFTime *self,SoMFTime const *other){ *self = *other; }

static void
convert_SoMFUInt32_array(PyObject * input, int len, uint32_t * temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (uint32_t) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
      free(temp);       
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN uint32_t const SoMFUInt32___getitem__(SoMFUInt32 *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFUInt32___setitem__(SoMFUInt32 *self,int i,uint32_t value){ self->set1Value(i, value); }
SWIGINTERN void SoMFUInt32_setValue__SWIG_1(SoMFUInt32 *self,SoMFUInt32 const *other){ *self = *other; }
SWIGINTERN uint32_t const *SoMFUInt32___getValuesHelper____SWIG_0(SoMFUInt32 *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFUShort_array(PyObject *input, int len, unsigned short *temp)
{
  int i;
  for (i=0; i<len; i++) {
    PyObject *oi = PySequence_GetItem(input, i);
    if (PyNumber_Check(oi)) {
      temp[i] = (short) PyInt_AsLong(oi);
    } else {
      PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
      free(temp);
      Py_DECREF(oi);
      return;
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN short const SoMFUShort___getitem__(SoMFUShort *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFUShort___setitem__(SoMFUShort *self,int i,short value){ self->set1Value(i, value); }
SWIGINTERN void SoMFUShort_setValue__SWIG_1(SoMFUShort *self,SoMFUShort const *other){ *self = *other; }
SWIGINTERN unsigned short const *SoMFUShort___getValuesHelper____SWIG_0(SoMFUShort *self,int &len,int i=0){
    if (i < 0 || i > self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }

static void
convert_SoMFVec3d_array(PyObject * input, int len, double temp[][3])
{
  int i,j;
  for (i=0; i<len; i++) {
    PyObject * oi = PySequence_GetItem(input, i);
    for (j=0; j<3; j++) {
      PyObject * oj = PySequence_GetItem(oi, j);
      if (PyNumber_Check(oj)) {
        temp[i][j] = PyFloat_AsDouble(oj);
      } else {
        PyErr_SetString(PyExc_ValueError, "Sequence elements must be numbers");
        free(temp);       
        Py_DECREF(oi);
        Py_DECREF(oj);
        return;
      }
      Py_DECREF(oj);
    }
    Py_DECREF(oi);
  }
  return;
}

SWIGINTERN SbVec3d const &SoMFVec3d___getitem__(SoMFVec3d *self,int i){ return (*self)[i]; }
SWIGINTERN void SoMFVec3d___setitem__(SoMFVec3d *self,int i,SbVec3d const &value){ self->set1Value(i, value); }
SWIGINTERN void SoMFVec3d_setValue__SWIG_3(SoMFVec3d *self,SoMFVec3d const *other){ *self = *other; }
SWIGINTERN SbVec3d const *SoMFVec3d___getValuesHelper____SWIG_0(SoMFVec3d *self,int &len,int i=0){
    if (i < 0 || i >= self->getNum()) { return NULL; }
    len = self->getNum() - i;
    return self->getValues(i);
  }
SWIGINTERN void SbStringList___setitem__(SbStringList *self,int const i,SbString *value){ self->set(i,value); }
SWIGINTERN SbString *SbStringList___getitem__(SbStringList *self,int i){ return (*self)[i]; }
SWIGINTERN SbString *SbStringList_get(SbStringList *self,int const i){ return (*self)[i]; }
SWIGINTERN void SbVec3fList___setitem__(SbVec3fList *self,int const i,SbVec3f *value){ self->set(i,value); }
SWIGINTERN SbVec3f *SbVec3fList___getitem__(SbVec3fList *self,int i){ return (*self)[i]; }
SWIGINTERN SbVec3f *SbVec3fList_get(SbVec3fList *self,int const i){ return (*self)[i]; }

static void
convert_SbDPMat_array(PyObject * input, SbDPMat temp)
{
  if (PySequence_Check(input) && (PySequence_Size(input) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 0)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 1)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 2)) == 4) &&
      (PySequence_Size(PySequence_GetItem(input, 3)) == 4)) {
    int i,j;
    for (i=0; i < 4; i++) {
      for (j=0; j < 4; j++) {
        PyObject * oij = PySequence_GetItem(PySequence_GetItem(input, i), j);
        if (!PyNumber_Check(oij)) {
          PyErr_SetString(PyExc_TypeError,
                          "sequence must contain 4 sequences where every sequence contains 4 floats");
          PyErr_Print();
          return;
        }
        temp[i][j] = PyFloat_AsDouble(oij);
        Py_DECREF(oij);
      }
    }
  } else {
    PyErr_SetString(PyExc_TypeError,
                    "sequence must contain 4 sequences where every sequence contains 4 floats");
    PyErr_Print();
  }
}

SWIGINTERN SbDPMatrix SbDPMatrix___mul____SWIG_0(SbDPMatrix *self,SbDPMatrix const &u){ return *self * u; }
SWIGINTERN SbVec3d SbDPMatrix___mul____SWIG_1(SbDPMatrix *self,SbVec3d const &u){ SbVec3d res; self->multMatrixVec(u, res); return res; }
SWIGINTERN SbVec3d SbDPMatrix___rmul__(SbDPMatrix *self,SbVec3d const &u){ SbVec3d res; self->multVecMatrix(u, res); return res; }
SWIGINTERN int SbDPMatrix___eq__(SbDPMatrix *self,SbDPMatrix const &u){ return *self == u; }
SWIGINTERN int SbDPMatrix___ne__(SbDPMatrix *self,SbDPMatrix const &u){ return *self != u; }
SWIGINTERN int SoGroup___len__(SoGroup *self){ return self->getNumChildren(); }
SWIGINTERN int SoGroup___contains__(SoGroup *self,SoNode const *node){ return (self->findChild(node) != -1); }
SWIGINTERN SoNode *SoGroup___getitem__(SoGroup *self,int index){
        if (index >= 0 && index < self->getNumChildren())
        {
            return self->getChild(index); 
        }
        else{
            PyErr_SetString(PyExc_IndexError,"index out of bounds");
            PyErr_Print();
            return NULL;
        }
    }

static void
SoPythonCallBack(void * userdata, SoAction * action)
{
  PyGILState_STATE gil = PyGILState_Ensure();
  PyObject *func, *arglist;
  PyObject *result, *acCB;

  acCB = SWIG_NewPointerObj((void *) action, SWIGTYPE_p_SoAction, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)userdata, 1), acCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(acCB);
  Py_XDECREF(result);
  PyGILState_Release(gil);
}

SWIGINTERN void SoCallback_setCallback__SWIG_2(SoCallback *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->setCallback(SoPythonCallBack, 
                      (void *)Py_BuildValue("(OO)", 
                                            pyfunc, 
                                            userdata ? userdata : Py_None));
  }

static void
SoEventPythonCallBack(void * userdata, SoEventCallback * node)
{
  PyGILState_STATE gil = PyGILState_Ensure();
  PyObject *func, *arglist;
  PyObject *result, *evCB;

  evCB = SWIG_NewPointerObj((void *) node, SWIGTYPE_p_SoEventCallback, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)userdata, 1), evCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(evCB);
  Py_XDECREF(result);
  PyGILState_Release(gil);
}

SWIGINTERN PyObject *SoEventCallback_addEventCallback__SWIG_2(SoEventCallback *self,SoType eventtype,PyObject *pyfunc,PyObject *userdata=NULL){

    PyObject* tuple = Py_BuildValue("(OO)", pyfunc, userdata ? userdata : Py_None);
    Py_XINCREF(tuple);
    self->addEventCallback(eventtype, SoEventPythonCallBack, (void *)tuple);
    return tuple;
  }
SWIGINTERN void SoEventCallback_removeEventCallback__SWIG_2(SoEventCallback *self,SoType eventtype,PyObject *tuple){
    self->removeEventCallback(eventtype, SoEventPythonCallBack,
                              (void *)tuple);
    Py_XDECREF(tuple);
  }

static void
SoSelectionPathPythonCB(void * data, SoPath * path)
{
  PyGILState_STATE gil = PyGILState_Ensure();
  PyObject *func, *arglist;
  PyObject *result, *pathCB;

  pathCB = SWIG_NewPointerObj((void *) path, SWIGTYPE_p_SoPath, 0);

  /* the first item in the data sequence is the python callback
   * function; the second is the supplied data python object */
  func = PyTuple_GetItem((PyObject *)data, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)data, 1), pathCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(pathCB);
  Py_XDECREF(result);
  PyGILState_Release(gil);
}

static void
SoSelectionClassPythonCB(void * data, SoSelection * sel)
{
  PyObject *func, *arglist;
  PyObject *result, *selCB;

  selCB = SWIG_NewPointerObj((void *) sel, SWIGTYPE_p_SoSelection, 0);

  /* the first item in the data sequence is the python callback
   * function; the second is the supplied data python object */
  func = PyTuple_GetItem((PyObject *)data, 0);
  arglist = Py_BuildValue("OO", PyTuple_GetItem((PyObject *)data, 1), selCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(selCB);
  Py_XDECREF(result);
}

static SoPath *
SoSelectionPickPythonCB(void * data, const SoPickedPoint * pick)
{
  PyObject *func, *arglist;
  PyObject *result, *pickCB;
  SoPath *resultobj;

  pickCB = SWIG_NewPointerObj((void *) pick, SWIGTYPE_p_SoPickedPoint, 0);

  /* the first item in the data sequence is the python callback
   * function; the second is the supplied data python object */
  func = PyTuple_GetItem((PyObject *)data, 0);
  arglist = Py_BuildValue("OO", PyTuple_GetItem((PyObject *)data, 1), pickCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }
  else {
    SWIG_ConvertPtr(result, (void **) &resultobj, SWIGTYPE_p_SoPath, 1);
  }

  Py_DECREF(arglist);
  Py_DECREF(pickCB);
  Py_XDECREF(result);

  return resultobj;
}

SWIGINTERN void SoSelection_addSelectionCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->addSelectionCallback(SoSelectionPathPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_removeSelectionCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->removeSelectionCallback(SoSelectionPathPythonCB,
                                  (void *)Py_BuildValue("(OO)",
                                                        pyfunc,
                                                        userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_addDeselectionCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->addDeselectionCallback(SoSelectionPathPythonCB,
                                 (void *)Py_BuildValue("(OO)",
                                                       pyfunc,
                                                       userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_removeDeselectionCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->removeDeselectionCallback(SoSelectionPathPythonCB,
                                    (void *)Py_BuildValue("(OO)",
                                                          pyfunc,
                                                          userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_addStartCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->addStartCallback(SoSelectionClassPythonCB,
                           (void *)Py_BuildValue("(OO)",
                                                 pyfunc,
                                                 userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_removeStartCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->removeStartCallback(SoSelectionClassPythonCB,
                              (void *)Py_BuildValue("(OO)",
                                                    pyfunc,
                                                    userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_addFinishCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->addFinishCallback(SoSelectionClassPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_removeFinishCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->removeFinishCallback(SoSelectionClassPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_setPickFilterCallback__SWIG_3(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL,int callOnlyIfSelectable=1){
    self->setPickFilterCallback(SoSelectionPickPythonCB,
                                (void *)Py_BuildValue("(OO)",
                                                      pyfunc,
                                                      userdata ? userdata : Py_None),
                                callOnlyIfSelectable);
  }
SWIGINTERN void SoSelection_addChangeCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->addChangeCallback(SoSelectionClassPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  userdata ? userdata : Py_None));
  }
SWIGINTERN void SoSelection_removeChangeCallback__SWIG_2(SoSelection *self,PyObject *pyfunc,PyObject *userdata=NULL){
    self->removeChangeCallback(SoSelectionClassPythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     userdata ? userdata : Py_None));
  }
SWIGINTERN void SoMarkerSet_addMarker__SWIG_3(int idx,SbVec2s const &size,PyObject *string,SbBool isLSBFirst=1,SbBool isUpToDown=1){
        short WIDTH, HEIGHT;
        size.getValue(WIDTH, HEIGHT);
        short BYTEWIDTH = (WIDTH + 7) / 2;
        const char* coin_marker;






        if (PyUnicode_Check(string))
        {
            coin_marker = PyUnicode_AsUTF8(string);            
        }
        else if (PyBytes_Check(string))
        {
            coin_marker = PyBytes_AsString(string);
        }

        else
        {
            return;
            // raise an attribute error: PyObject string should be of type bytes!
        }
        // https://grey.colorado.edu/coin3d/classSoMarkerSet.html
        // from addMarker example:

        int byteidx = 0;
        unsigned char* bitmapbytes = NULL;
        bitmapbytes = new unsigned char[BYTEWIDTH * HEIGHT];
        
        for (int h = 0; h < HEIGHT; h++)
        {
            unsigned char bits = 0;
            for (int w = 0; w < WIDTH; w++)
            {
                if (coin_marker[(h * WIDTH) + w] != ' ') { bits |= (0x80 >> (w % 8)); }
                if ((((w + 1) % 8) == 0) || (w == WIDTH - 1)) {
                bitmapbytes[byteidx++] = bits;
                bits = 0;
                }
            }
        }
        SoMarkerSet::addMarker(idx, size, bitmapbytes, isLSBFirst, isUpToDown);
        delete[] bitmapbytes;
        bitmapbytes = NULL;
    }
SWIGINTERN SbDPRotation SbDPRotation___mul____SWIG_0(SbDPRotation *self,SbDPRotation const &u){ return *self * u; }
SWIGINTERN SbDPRotation SbDPRotation___mul____SWIG_1(SbDPRotation *self,double const d){ SbDPRotation res(*self); return (res *= d); }
SWIGINTERN SbVec3d SbDPRotation___mul____SWIG_2(SbDPRotation *self,SbVec3d const &v){ SbVec3d res; self->multVec(v, res); return res; }
SWIGINTERN int SbDPRotation___eq__(SbDPRotation *self,SbDPRotation const &u){ return *self == u; }
SWIGINTERN int SbDPRotation___nq__(SbDPRotation *self,SbDPRotation const &u){ return *self != u; }
SWIGINTERN int SbDPPlane___eq__(SbDPPlane *self,SbDPPlane const &u){ return *self == u; }
SWIGINTERN int SbDPPlane___ne__(SbDPPlane *self,SbDPPlane const &u){ return *self != u; }
SWIGINTERN PyObject *SbImage_getValue__SWIG_2(SbImage *self){
    int nc;
    SbVec3s size;
    PyObject * result;

    const unsigned char * image = self->getValue(size, nc);
    
    /* check for 3D image */
    if (size[2] == 0) {
      SbVec2s * vec2s = new SbVec2s(size[0], size[1]);
      result = Py_BuildValue("(s#Oi)",
                             (const char*)image,
                             (*vec2s)[0] * (*vec2s)[1] * nc,
                             SWIG_NewPointerObj((void *)vec2s, SWIGTYPE_p_SbVec2s, 1),
                             nc);
    } else {
      SbVec3s * vec3s = new SbVec3s(size[0], size[1], size[2]);
      result = Py_BuildValue("(s#Oi)",
                             (const char*)image,
                             (*vec3s)[0] * (*vec3s)[1] * (*vec3s)[2] * nc,
                             SWIG_NewPointerObj((void *)vec3s, SWIGTYPE_p_SbVec3s, 1),
                             nc);
    }
      
    return result;
  }
SWIGINTERN PyObject *SoOffscreenRenderer_getBuffer__SWIG_1(SoOffscreenRenderer *self){
    SbVec2s size = self->getViewportRegion().getWindowSize();




    return PyBytes_FromStringAndSize((char *)self->getBuffer(),
                                      size[0] * size[1] * self->getComponents());

  }

static void
SoSceneManagerPythonCB(void * userdata, SoSceneManager * mgr)
{
  PyObject *func, *arglist;
  PyObject *result, *mgrCB;

  mgrCB = SWIG_NewPointerObj((void *)mgr, SWIGTYPE_p_SoSceneManager, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("OO", PyTuple_GetItem((PyObject *)userdata, 1), mgrCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }  

  Py_DECREF(arglist);
  Py_DECREF(mgrCB);
  Py_XDECREF(result);
}

SWIGINTERN void SoSceneManager_setRenderCallback__SWIG_2(SoSceneManager *self,PyObject *pyfunc,PyObject *userData=NULL){
    self->setRenderCallback(SoSceneManagerPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  userData ? userData : Py_None));
  }

static void
SoRenderManagerRenderPythonCB(void * userdata, class SoRenderManager * mgr)
{
  PyObject *func, *arglist;
  PyObject *result, *mgrCB;

  mgrCB = SWIG_NewPointerObj((void *)mgr, SWIGTYPE_p_SoRenderManager, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("OO", PyTuple_GetItem((PyObject *)userdata, 1), mgrCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }  

  Py_DECREF(arglist);
  Py_DECREF(mgrCB);
  Py_XDECREF(result);
}

SWIGINTERN void SoRenderManager_setRenderCallback__SWIG_2(SoRenderManager *self,PyObject *pyfunc,PyObject *userData=NULL){
    self->setRenderCallback(SoRenderManagerRenderPythonCB,
                            (void *)Py_BuildValue("(OO)",
                                                  pyfunc,
                                                  userData ? userData : Py_None));
  }
SWIGINTERN void SoRenderManager_addPreRenderCallback__SWIG_1(SoRenderManager *self,PyObject *pyfunc,PyObject *data){
    self->addPreRenderCallback(SoRenderManagerRenderPythonCB,
			       (void *)Py_BuildValue("(OO)",
						     pyfunc,
						     data ? data : Py_None));
  }
SWIGINTERN void SoRenderManager_removePreRenderCallback__SWIG_1(SoRenderManager *self,PyObject *pyfunc,PyObject *data){
    self->removePreRenderCallback(SoRenderManagerRenderPythonCB,
				  (void *)Py_BuildValue("(OO)",
							pyfunc,
							data ? data : Py_None));
  }
SWIGINTERN void SoRenderManager_addPostRenderCallback__SWIG_1(SoRenderManager *self,PyObject *pyfunc,PyObject *data){
    self->addPostRenderCallback(SoRenderManagerRenderPythonCB,
				(void *)Py_BuildValue("(OO)",
						      pyfunc,
						      data ? data : Py_None));
  }
SWIGINTERN void SoRenderManager_removePostRenderCallback__SWIG_1(SoRenderManager *self,PyObject *pyfunc,PyObject *data){
    self->removePostRenderCallback(SoRenderManagerRenderPythonCB,
				   (void *)Py_BuildValue("(OO)",
							 pyfunc,
							 data ? data : Py_None));
  }

static void
ScXMLStateMachineDeletePythonCB(void * userdata,
				ScXMLStateMachine * statemachine)
{
  PyObject *func, *arglist;
  PyObject *result, *statemachineCB;

  statemachineCB = SWIG_NewPointerObj((void *)statemachine, SWIGTYPE_p_ScXMLStateMachine, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OO)", PyTuple_GetItem((PyObject *)userdata, 1), statemachineCB);

  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(statemachineCB);
  Py_XDECREF(result);
}

static void
ScXMLStateChangePythonCB(void * userdata,
			 ScXMLStateMachine * statemachine,
			 const char * stateidentifier,
			 SbBool enterstate,
			 SbBool success)
{
  PyObject *func, *arglist;
  PyObject *result, *statemachineCB;

  statemachineCB = SWIG_NewPointerObj((void *)statemachine, SWIGTYPE_p_ScXMLStateMachine, 0);

  /* the first item in the userdata sequence is the python callback
   * function; the second is the supplied userdata python object */
  func = PyTuple_GetItem((PyObject *)userdata, 0);
  arglist = Py_BuildValue("(OOsii)", PyTuple_GetItem((PyObject *)userdata, 1),
			  statemachineCB, stateidentifier,
			  enterstate, success);
  
  if ((result = PyObject_CallObject(func, arglist)) == NULL) {
    PyErr_Print();
  }

  Py_DECREF(arglist);
  Py_DECREF(statemachineCB);
  Py_XDECREF(result);
}

SWIGINTERN void ScXMLStateMachine_addDeleteCallback__SWIG_1(ScXMLStateMachine *self,PyObject *pyfunc,PyObject *userdata){
    self->addDeleteCallback(ScXMLStateMachineDeletePythonCB,
			    (void *)Py_BuildValue("(OO)",
						  pyfunc,
						  userdata ? userdata : Py_None));
  }
SWIGINTERN void ScXMLStateMachine_removeDeleteCallback__SWIG_1(ScXMLStateMachine *self,PyObject *pyfunc,PyObject *userdata){
    self->removeDeleteCallback(ScXMLStateMachineDeletePythonCB,
                               (void *)Py_BuildValue("(OO)",
                                                     pyfunc,
                                                     userdata ? userdata : Py_None));
  }
SWIGINTERN void ScXMLStateMachine_addStateChangeCallback__SWIG_1(ScXMLStateMachine *self,PyObject *pyfunc,PyObject *userdata){
    self->addStateChangeCallback(ScXMLStateChangePythonCB,
				 (void *)Py_BuildValue("(OO)",
						       pyfunc,
						       userdata ? userdata : Py_None));
  }
SWIGINTERN void ScXMLStateMachine_removeStateChangeCallback__SWIG_1(ScXMLStateMachine *self,PyObject *pyfunc,PyObject *userdata){
    self->removeStateChangeCallback(ScXMLStateChangePythonCB,
				    (void *)Py_BuildValue("(OO)",
							  pyfunc,
							  userdata ? userdata : Py_None));
  }
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_charp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  charp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_charp", 0, 0, 0)) SWIG_fail;
  result = (charp *)new_charp();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_charp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_charp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  charp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_charp" "', argument " "1"" of type '" "charp *""'"); 
  }
  arg1 = reinterpret_cast< charp * >(argp1);
  delete_charp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_charp_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  charp *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "charp_assign", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charp_assign" "', argument " "1"" of type '" "charp *""'"); 
  }
  arg1 = reinterpret_cast< charp * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "charp_assign" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  charp_assign(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_charp_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  charp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charp_value" "', argument " "1"" of type '" "charp *""'"); 
  }
  arg1 = reinterpret_cast< charp * >(argp1);
  result = (char)charp_value(arg1);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_charp_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  charp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charp_cast" "', argument " "1"" of type '" "charp *""'"); 
  }
  arg1 = reinterpret_cast< charp * >(argp1);
  result = (char *)charp_cast(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_charp_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  charp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charp_frompointer" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (charp *)charp_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_charp, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *charp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_charp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *charp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_intp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_intp", 0, 0, 0)) SWIG_fail;
  result = (intp *)new_intp();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_intp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intp" "', argument " "1"" of type '" "intp *""'"); 
  }
  arg1 = reinterpret_cast< intp * >(argp1);
  delete_intp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intp_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intp *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); 
  }
  arg1 = reinterpret_cast< intp * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  intp_assign(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intp_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_value" "', argument " "1"" of type '" "intp *""'"); 
  }
  arg1 = reinterpret_cast< intp * >(argp1);
  result = (int)intp_value(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intp_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_cast" "', argument " "1"" of type '" "intp *""'"); 
  }
  arg1 = reinterpret_cast< intp * >(argp1);
  result = (int *)intp_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  intp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  result = (intp *)intp_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *intp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_intp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *intp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_longp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  longp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_longp", 0, 0, 0)) SWIG_fail;
  result = (longp *)new_longp();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_longp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_longp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  longp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_longp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_longp" "', argument " "1"" of type '" "longp *""'"); 
  }
  arg1 = reinterpret_cast< longp * >(argp1);
  delete_longp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_longp_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  longp *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "longp_assign", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_longp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longp_assign" "', argument " "1"" of type '" "longp *""'"); 
  }
  arg1 = reinterpret_cast< longp * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "longp_assign" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  longp_assign(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_longp_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  longp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_longp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longp_value" "', argument " "1"" of type '" "longp *""'"); 
  }
  arg1 = reinterpret_cast< longp * >(argp1);
  result = (long)longp_value(arg1);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_longp_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  longp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_longp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longp_cast" "', argument " "1"" of type '" "longp *""'"); 
  }
  arg1 = reinterpret_cast< longp * >(argp1);
  result = (long *)longp_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_longp_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  long *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  longp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longp_frompointer" "', argument " "1"" of type '" "long *""'"); 
  }
  arg1 = reinterpret_cast< long * >(argp1);
  result = (longp *)longp_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_longp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *longp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_longp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *longp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_floatp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatp *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_floatp", 0, 0, 0)) SWIG_fail;
  result = (floatp *)new_floatp();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_floatp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatp" "', argument " "1"" of type '" "floatp *""'"); 
  }
  arg1 = reinterpret_cast< floatp * >(argp1);
  delete_floatp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatp_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatp *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "floatp_assign", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatp_assign" "', argument " "1"" of type '" "floatp *""'"); 
  }
  arg1 = reinterpret_cast< floatp * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatp_assign" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  floatp_assign(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatp_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatp_value" "', argument " "1"" of type '" "floatp *""'"); 
  }
  arg1 = reinterpret_cast< floatp * >(argp1);
  result = (float)floatp_value(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatp_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatp *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatp_cast" "', argument " "1"" of type '" "floatp *""'"); 
  }
  arg1 = reinterpret_cast< floatp * >(argp1);
  result = (float *)floatp_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatp_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  floatp *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatp_frompointer" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  result = (floatp *)floatp_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatp, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *floatp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_floatp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *floatp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_doublep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doublep *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_doublep", 0, 0, 0)) SWIG_fail;
  result = (doublep *)new_doublep();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doublep, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doublep *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doublep" "', argument " "1"" of type '" "doublep *""'"); 
  }
  arg1 = reinterpret_cast< doublep * >(argp1);
  delete_doublep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doublep *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); 
  }
  arg1 = reinterpret_cast< doublep * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  doublep_assign(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doublep_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doublep *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_value" "', argument " "1"" of type '" "doublep *""'"); 
  }
  arg1 = reinterpret_cast< doublep * >(argp1);
  result = (double)doublep_value(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doublep *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_cast" "', argument " "1"" of type '" "doublep *""'"); 
  }
  arg1 = reinterpret_cast< doublep * >(argp1);
  result = (double *)doublep_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  doublep *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  result = (doublep *)doublep_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doublep, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *doublep_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_doublep, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *doublep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbDict__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbDict *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbDict" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbDict *)new SbDict(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDict, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDict__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbDict *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDict *)new SbDict();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDict, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDict__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDict *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbDict,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDict" "', argument " "1"" of type '" "SbDict const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDict" "', argument " "1"" of type '" "SbDict const &""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  result = (SbDict *)new SbDict((SbDict const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDict, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDict(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbDict", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbDict__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbDict, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbDict__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbDict__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbDict'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDict::SbDict(int const)\n"
    "    SbDict::SbDict()\n"
    "    SbDict::SbDict(SbDict const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbDict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDict" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_applyToAll__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDictApplyFunc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_applyToAll" "', argument " "1"" of type '" "SbDict const *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_unsigned_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbDict_applyToAll" "', argument " "2"" of type '" "SbDictApplyFunc *""'"); 
    }
  }
  ((SbDict const *)arg1)->applyToAll(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_applyToAll__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDictApplyDataFunc *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_applyToAll" "', argument " "1"" of type '" "SbDict const *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_unsigned_int_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbDict_applyToAll" "', argument " "2"" of type '" "SbDictApplyDataFunc *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDict_applyToAll" "', argument " "3"" of type '" "void *""'"); 
  }
  ((SbDict const *)arg1)->applyToAll(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_applyToAll(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDict_applyToAll", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDict, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_unsigned_int_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDict_applyToAll__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDict, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_unsigned_int_p_void_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDict_applyToAll__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDict_applyToAll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDict::applyToAll(SbDictApplyFunc *) const\n"
    "    SbDict::applyToAll(SbDictApplyDataFunc *,void *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDict_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_clear" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_enter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDict::Key arg2 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDict_enter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_enter" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDict_enter" "', argument " "2"" of type '" "SbDict::Key""'");
  } 
  arg2 = static_cast< SbDict::Key >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDict_enter" "', argument " "3"" of type '" "void *const""'"); 
  }
  result = (SbBool)(arg1)->enter(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDict::Key arg2 ;
  void **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDict_find", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_find" "', argument " "1"" of type '" "SbDict const *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDict_find" "', argument " "2"" of type '" "SbDict::Key""'");
  } 
  arg2 = static_cast< SbDict::Key >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDict_find" "', argument " "3"" of type '" "void *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDict_find" "', argument " "3"" of type '" "void *&""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);
  result = (SbBool)((SbDict const *)arg1)->find(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_makePList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbPList *arg2 = 0 ;
  SbPList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDict_makePList", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_makePList" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDict_makePList" "', argument " "2"" of type '" "SbPList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDict_makePList" "', argument " "2"" of type '" "SbPList &""'"); 
  }
  arg2 = reinterpret_cast< SbPList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDict_makePList" "', argument " "3"" of type '" "SbPList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDict_makePList" "', argument " "3"" of type '" "SbPList &""'"); 
  }
  arg3 = reinterpret_cast< SbPList * >(argp3);
  (arg1)->makePList(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDict::Key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDict_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_remove" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDict_remove" "', argument " "2"" of type '" "SbDict::Key""'");
  } 
  arg2 = static_cast< SbDict::Key >(val2);
  result = (SbBool)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDict_setHashingFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDict *arg1 = 0 ;
  SbDictHashingFunc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDict_setHashingFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDict_setHashingFunction" "', argument " "1"" of type '" "SbDict *""'"); 
  }
  arg1 = reinterpret_cast< SbDict * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_q_const__unsigned_int__unsigned_int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbDict_setHashingFunction" "', argument " "2"" of type '" "SbDictHashingFunc *""'"); 
    }
  }
  (arg1)->setHashingFunction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbDict_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDict, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDict_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoType_fromName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  result = SoType::fromName(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getName" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = ((SoType const *)arg1)->getName();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getParent" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = ((SoType const *)arg1)->getParent();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_isDerivedFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType_isDerivedFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_isDerivedFrom" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType_isDerivedFrom" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType_isDerivedFrom" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->isDerivedFrom(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getAllDerivedFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoTypeList *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType_getAllDerivedFrom", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getAllDerivedFrom" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType_getAllDerivedFrom" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoTypeList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType_getAllDerivedFrom" "', argument " "2"" of type '" "SoTypeList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType_getAllDerivedFrom" "', argument " "2"" of type '" "SoTypeList &""'"); 
  }
  arg2 = reinterpret_cast< SoTypeList * >(argp2);
  result = (int)SoType::getAllDerivedFrom(SWIG_STD_MOVE(arg1),*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_canCreateInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_canCreateInstance" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (SbBool)((SoType const *)arg1)->canCreateInstance();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getData" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (uint16_t)((SoType const *)arg1)->getData();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int16_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getKey" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (int16_t)((SoType const *)arg1)->getKey();
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___eq__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___eq__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___eq__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator ==(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___ne__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___ne__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___ne__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator !=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___lt__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___lt__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___lt__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator <(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___le__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___le__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___le__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator <=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___ge__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___ge__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___ge__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator >=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType___gt__" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoType___gt__" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoType___gt__" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoType const *)arg1)->operator >(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoType_removeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SbBool)SoType::removeType((SbName const &)*arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType_init", 0, 0, 0)) SWIG_fail;
  SoType::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_fromKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint16_t arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoType_fromKey" "', argument " "1"" of type '" "uint16_t""'");
  } 
  arg1 = static_cast< uint16_t >(val1);
  result = SoType::fromKey(arg1);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_badType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType_badType", 0, 0, 0)) SWIG_fail;
  result = SoType::badType();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_isBad(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_isBad" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (SbBool)((SoType const *)arg1)->isBad();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_makeInternal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_makeInternal" "', argument " "1"" of type '" "SoType *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  (arg1)->makeInternal();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_isInternal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_isInternal" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (SbBool)((SoType const *)arg1)->isInternal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getNumTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoType_getNumTypes", 0, 0, 0)) SWIG_fail;
  result = (int)SoType::getNumTypes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_getInstantiationMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType::instantiationMethod result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_getInstantiationMethod" "', argument " "1"" of type '" "SoType const *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (SoType::instantiationMethod)((SoType const *)arg1)->getInstantiationMethod();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_void__p_void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoType_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoType_createInstance" "', argument " "1"" of type '" "SoType *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (PyObject *)SoType_createInstance(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoType", 0, 0, 0)) SWIG_fail;
  result = (SoType *)new SoType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoType" "', argument " "1"" of type '" "SoType *""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbPList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbPList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbPList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbPList *)new SbPList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbPList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbPList *)new SbPList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbPList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbPList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPList" "', argument " "1"" of type '" "SbPList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPList" "', argument " "1"" of type '" "SbPList const &""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  result = (SbPList *)new SbPList((SbPList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbPList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbPList__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbPList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbPList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbPList__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbPList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPList::SbPList(int const)\n"
    "    SbPList::SbPList()\n"
    "    SbPList::SbPList(SbPList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbPList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbPList" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  SbPList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_copy" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList_copy" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPList_copy" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  arg2 = reinterpret_cast< SbPList * >(argp2);
  (arg1)->copy((SbPList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_fit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_fit" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  (arg1)->fit();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_append" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList_append" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_find" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList_find" "', argument " "2"" of type '" "void const *""'"); 
  }
  result = (int)((SbPList const *)arg1)->find((void const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_insert" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList_insert" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbPList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_removeItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_removeItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_removeItem" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList_removeItem" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->removeItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_remove" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_removeFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_removeFast", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_removeFast" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_removeFast" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeFast(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_getLength" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  result = (int)((SbPList const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_truncate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_truncate" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbPList_truncate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->truncate(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_truncate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_truncate" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_truncate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbPList_truncate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbPList_truncate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbPList_truncate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbPList_truncate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPList::truncate(int const,int const)\n"
    "    SbPList::truncate(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbPList_getArrayPtr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void **result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_getArrayPtr" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_getArrayPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void **)((SbPList const *)arg1)->getArrayPtr(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_getArrayPtr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void **result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_getArrayPtr" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  result = (void **)((SbPList const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_getArrayPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbPList_getArrayPtr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbPList_getArrayPtr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbPList_getArrayPtr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbPList_getArrayPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPList::getArrayPtr(int const) const\n"
    "    SbPList::getArrayPtr() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbPList___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  SbPList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList___eq__" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList___eq__" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPList___eq__" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  arg2 = reinterpret_cast< SbPList * >(argp2);
  result = (int)((SbPList const *)arg1)->operator ==((SbPList const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbPList___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  SbPList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList___ne__" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPList___ne__" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPList___ne__" "', argument " "2"" of type '" "SbPList const &""'"); 
  }
  arg2 = reinterpret_cast< SbPList * >(argp2);
  result = (int)((SbPList const *)arg1)->operator !=((SbPList const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbPList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_get" "', argument " "1"" of type '" "SbPList const *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void *)((SbPList const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList_set" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbPList_set" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList___getitem__" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void *)SbPList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPList *arg1 = 0 ;
  int arg2 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPList___setitem__" "', argument " "1"" of type '" "SbPList *""'"); 
  }
  arg1 = reinterpret_cast< SbPList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbPList___setitem__" "', argument " "3"" of type '" "void *""'"); 
  }
  SbPList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbPList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbPList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbPList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbIntList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbIntList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbIntList *)new SbIntList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbIntList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbIntList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbIntList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbIntList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbIntList *)new SbIntList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbIntList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbIntList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbIntList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbIntList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbIntList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbIntList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbIntList::SbIntList()\n"
    "    SbIntList::SbIntList(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbIntList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList_append" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbIntList_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList_find" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList_find" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbIntList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList_insert" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbIntList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbIntList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList___setitem__" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbIntList___setitem__" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  SbIntList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbIntList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList___getitem__" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int *) &SbIntList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbIntList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbIntList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbIntList_get" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbIntList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)SbIntList_get(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbIntList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbIntList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbIntList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbIntList" "', argument " "1"" of type '" "SbIntList *""'"); 
  }
  arg1 = reinterpret_cast< SbIntList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbIntList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbIntList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbIntList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbString *)new SbString();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SbString *)new SbString((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  wchar_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wchar_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbString" "', argument " "1"" of type '" "wchar_t const *""'"); 
  }
  arg1 = reinterpret_cast< wchar_t * >(argp1);
  result = (SbString *)new SbString((wchar_t const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbString *)new SbString((char const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SbString *)new SbString((SbString const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbString *)new SbString(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbString__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_wchar_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbString__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbString__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbString__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_SbString__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbString__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::SbString()\n"
    "    SbString::SbString(char const *)\n"
    "    SbString::SbString(wchar_t const *)\n"
    "    SbString::SbString(char const *,int,int)\n"
    "    SbString::SbString(SbString const &)\n"
    "    SbString::SbString(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbString" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_hash__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_hash" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = (uint32_t)((SbString const *)arg1)->hash();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_hash__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_hash" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (uint32_t)SbString::hash((char const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_hash(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString_hash", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbString_hash__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbString_hash__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString_hash'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::hash() const\n"
    "    SbString::hash(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_getLength" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = (int)((SbString const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_makeEmpty__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_makeEmpty" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_makeEmpty" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->makeEmpty(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_makeEmpty__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_makeEmpty" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_makeEmpty(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString_makeEmpty", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbString_makeEmpty__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbString_makeEmpty__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString_makeEmpty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::makeEmpty(SbBool)\n"
    "    SbString::makeEmpty()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_getString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_getString" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = (char *)((SbString const *)arg1)->getString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_getSubString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_getSubString" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_getSubString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbString_getSubString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = ((SbString const *)arg1)->getSubString(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_getSubString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_getSubString" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_getSubString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SbString const *)arg1)->getSubString(arg2);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_getSubString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString_getSubString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbString_getSubString__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbString_getSubString__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString_getSubString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::getSubString(int,int) const\n"
    "    SbString::getSubString(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_deleteSubString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_deleteSubString" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_deleteSubString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbString_deleteSubString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->deleteSubString(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_deleteSubString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_deleteSubString" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_deleteSubString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deleteSubString(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_deleteSubString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString_deleteSubString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbString_deleteSubString__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbString_deleteSubString__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString_deleteSubString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::deleteSubString(int,int)\n"
    "    SbString::deleteSubString(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_addIntString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString_addIntString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_addIntString" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString_addIntString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addIntString(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___iadd____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___iadd__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString___iadd__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbString *) &(arg1)->operator +=((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___iadd____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___iadd__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbString *) &(arg1)->operator +=((SbString const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___iadd____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___iadd__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString___iadd__" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = (SbString *) &(arg1)->operator +=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___iadd__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString___iadd__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbString___iadd____SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbString___iadd____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbString___iadd____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString___iadd__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::operator +=(char const *)\n"
    "    SbString::operator +=(SbString const &)\n"
    "    SbString::operator +=(char const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_compareSubString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_compareSubString" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString_compareSubString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbString_compareSubString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((SbString const *)arg1)->compareSubString((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_compareSubString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_compareSubString" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString_compareSubString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)((SbString const *)arg1)->compareSubString((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_compareSubString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString_compareSubString", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbString_compareSubString__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbString_compareSubString__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString_compareSubString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::compareSubString(char const *,int) const\n"
    "    SbString::compareSubString(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString_sprintf__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SbString *result = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SbString_sprintf", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_sprintf" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString_sprintf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbString *) &(arg1)->sprintf((char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_sprintf(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SbString_sprintf__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SbString_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char (*arg2)(char) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString_apply", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_apply" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_char__char);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbString_apply" "', argument " "2"" of type '" "char (*)(char)""'"); 
    }
  }
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_find" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SbString const *)arg1)->find((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_findAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbIntList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString_findAll", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_findAll" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbIntList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbString_findAll" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbString_findAll" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  arg3 = reinterpret_cast< SbIntList * >(argp3);
  result = (SbBool)((SbString const *)arg1)->findAll((SbString const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_lower(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_lower" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = ((SbString const *)arg1)->lower();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString_upper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString_upper" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = ((SbString const *)arg1)->upper();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  std::FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString__print", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString__print" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString__print" "', argument " "2"" of type '" "std::FILE *""'"); 
  }
  arg2 = reinterpret_cast< std::FILE * >(argp2);
  ((SbString const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___eq__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbString___eq____SWIG_0(arg1,(SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbString___nq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___nq__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbString___nq____SWIG_0(arg1,(SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___eq__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString___eq__" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)SbString___eq____SWIG_1(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbString___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbString___eq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbString___eq____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbString___nq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___nq__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbString___nq__" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)SbString___nq____SWIG_1(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___nq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbString___nq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbString___nq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbString___nq____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbString___nq__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbString::__nq__(SbString const &)\n"
    "    SbString::__nq__(char *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbString___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbString___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___getitem__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbString___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char)SbString___getitem__(arg1,arg2);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbString___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbString___repr__" "', argument " "1"" of type '" "SbString *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  result = (char *)SbString___repr__(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbString, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbString_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbName *)new SbName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SbName *)new SbName((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbName__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SbName *)new SbName((SbString const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, SWIG_POINTER_NEW |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbName__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SbName *)new SbName((SbName const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, SWIG_POINTER_NEW |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbName", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbName__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbName__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_SbName__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) && 
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_SbName__SWIG_3(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbName::SbName()\n"
    "    SbName::SbName(char const *)\n"
    "    SbName::SbName(SbString const &)\n"
    "    SbName::SbName(SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbName" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_getString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName_getString" "', argument " "1"" of type '" "SbName const *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  result = (char *)((SbName const *)arg1)->getString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName_getLength" "', argument " "1"" of type '" "SbName const *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  result = (int)((SbName const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_isIdentStartChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SbName_isIdentStartChar" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  result = (SbBool)SbName::isIdentStartChar(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_isIdentChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SbName_isIdentChar" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  result = (SbBool)SbName::isIdentChar(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_isBaseNameStartChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SbName_isBaseNameStartChar" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  result = (SbBool)SbName::isBaseNameStartChar(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_isBaseNameChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SbName_isBaseNameChar" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  result = (SbBool)SbName::isBaseNameChar(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbName_empty", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SbName::empty();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___eq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbName___eq____SWIG_0(arg1,(SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbName___nq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___nq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbName___nq____SWIG_0(arg1,(SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___eq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbName___eq__" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)SbName___eq____SWIG_1(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbName___nq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___nq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbName___nq__" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)SbName___nq____SWIG_1(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName___eq____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___eq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbName___eq____SWIG_2(arg1,(SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbName___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbName___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbName___eq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbName___eq____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbName___eq____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbName___nq____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___nq__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)SbName___nq____SWIG_2(arg1,(SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName___nq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbName___nq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbName___nq____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbName___nq____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbName___nq____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbName___nq__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbName::__nq__(SbName const &)\n"
    "    SbName::__nq__(char *)\n"
    "    SbName::__nq__(SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbName___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbName___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___getitem__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbName___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char)SbName___getitem__(arg1,arg2);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbName___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbName___repr__" "', argument " "1"" of type '" "SbName *""'"); 
  }
  arg1 = reinterpret_cast< SbName * >(argp1);
  result = (char *)SbName___repr__(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoError *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoError", 0, 0, 0)) SWIG_fail;
  result = (SoError *)new SoError();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoError" "', argument " "1"" of type '" "SoError *""'"); 
  }
  arg1 = reinterpret_cast< SoError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_setHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *arg1 = (SoErrorCB *)0 ;
  void *arg2 = (void *)0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_setHandlerCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoError_setHandlerCallback" "', argument " "1"" of type '" "SoErrorCB *const""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoError_setHandlerCallback" "', argument " "2"" of type '" "void *const""'"); 
  }
  SoError::setHandlerCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_getHandlerCallback", 0, 0, 0)) SWIG_fail;
  result = (SoErrorCB *)SoError::getHandlerCallback();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getHandlerData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_getHandlerData", 0, 0, 0)) SWIG_fail;
  result = (void *)SoError::getHandlerData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getDebugString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_getDebugString" "', argument " "1"" of type '" "SoError const *""'"); 
  }
  arg1 = reinterpret_cast< SoError * >(argp1);
  result = (SbString *) &((SoError const *)arg1)->getDebugString();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoError::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_getTypeId" "', argument " "1"" of type '" "SoError const *""'"); 
  }
  arg1 = reinterpret_cast< SoError * >(argp1);
  result = ((SoError const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoError *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_isOfType" "', argument " "1"" of type '" "SoError const *""'"); 
  }
  arg1 = reinterpret_cast< SoError * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoError_isOfType" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoError_isOfType" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoError const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_post__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  void *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SoError_post", 1, 1, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_post" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoError::post((char const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_post(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 1);
  varargs = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
  resultobj = _wrap_SoError_post__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SoError_getString__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_getString" "', argument " "1"" of type '" "SoNode const *const""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = SoError::getString((SoNode const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getString__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_getString" "', argument " "1"" of type '" "SoPath const *const""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = SoError::getString((SoPath const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getString__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = (SoEngine *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoError_getString" "', argument " "1"" of type '" "SoEngine const *const""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = SoError::getString((SoEngine const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_getString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoError_getString", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoError_getString__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoError_getString__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoError_getString__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoError_getString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoError::getString(SoNode const *const)\n"
    "    SoError::getString(SoPath const *const)\n"
    "    SoError::getString(SoEngine const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoError_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_initClass", 0, 0, 0)) SWIG_fail;
  SoError::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoError_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoError_initClasses", 0, 0, 0)) SWIG_fail;
  SoError::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDebugError_setHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *arg1 = (SoErrorCB *)0 ;
  void *arg2 = (void *)0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDebugError_setHandlerCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDebugError_setHandlerCallback" "', argument " "1"" of type '" "SoErrorCB *const""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDebugError_setHandlerCallback" "', argument " "2"" of type '" "void *const""'"); 
  }
  SoDebugError::setHandlerCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_getHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDebugError_getHandlerCallback", 0, 0, 0)) SWIG_fail;
  result = (SoErrorCB *)SoDebugError::getHandlerCallback();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_getHandlerData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDebugError_getHandlerData", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDebugError::getHandlerData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDebugError_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDebugError::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDebugError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDebugError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDebugError_getTypeId" "', argument " "1"" of type '" "SoDebugError const *""'"); 
  }
  arg1 = reinterpret_cast< SoDebugError * >(argp1);
  result = ((SoDebugError const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_getSeverity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDebugError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDebugError::Severity result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDebugError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDebugError_getSeverity" "', argument " "1"" of type '" "SoDebugError const *""'"); 
  }
  arg1 = reinterpret_cast< SoDebugError * >(argp1);
  result = (SoDebugError::Severity)((SoDebugError const *)arg1)->getSeverity();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_post__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  char *arg2 = (char *)0 ;
  void *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SoDebugError_post", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDebugError_post" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDebugError_post" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoDebugError::post((char const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_post(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SoDebugError_post__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SoDebugError_postWarning__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  char *arg2 = (char *)0 ;
  void *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SoDebugError_postWarning", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDebugError_postWarning" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDebugError_postWarning" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoDebugError::postWarning((char const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_postWarning(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SoDebugError_postWarning__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SoDebugError_postInfo__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  char *arg2 = (char *)0 ;
  void *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SoDebugError_postInfo", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDebugError_postInfo" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDebugError_postInfo" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoDebugError::postInfo((char const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDebugError_postInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SoDebugError_postInfo__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SoDebugError_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDebugError_initClass", 0, 0, 0)) SWIG_fail;
  SoDebugError::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDebugError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDebugError *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDebugError", 0, 0, 0)) SWIG_fail;
  result = (SoDebugError *)new SoDebugError();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDebugError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoDebugError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDebugError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDebugError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDebugError" "', argument " "1"" of type '" "SoDebugError *""'"); 
  }
  arg1 = reinterpret_cast< SoDebugError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDebugError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDebugError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDebugError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec2s *)new SbVec2s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short *arg1 = (short *)0 ;
  short temp1[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec2s_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec2s *)new SbVec2s((short const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec2s" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  result = (SbVec2s *)new SbVec2s(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2us,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2us const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2us const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2us * >(argp1);
  result = (SbVec2s *)new SbVec2s((SbVec2us const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = (SbVec2s *)new SbVec2s((SbVec2b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = (SbVec2s *)new SbVec2s((SbVec2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (SbVec2s *)new SbVec2s((SbVec2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2s" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (SbVec2s *)new SbVec2s((SbVec2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2s(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec2s", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec2s__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2us, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec2s__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbVec2s__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec2s'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2s::SbVec2s()\n"
    "    SbVec2s::SbVec2s(short const [2])\n"
    "    SbVec2s::SbVec2s(short,short)\n"
    "    SbVec2s::SbVec2s(SbVec2us const &)\n"
    "    SbVec2s::SbVec2s(SbVec2b const &)\n"
    "    SbVec2s::SbVec2s(SbVec2i32 const &)\n"
    "    SbVec2s::SbVec2s(SbVec2f const &)\n"
    "    SbVec2s::SbVec2s(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short temp2[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    convert_SbVec2s_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec2s *) &(arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  result = (SbVec2s *) &(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2us * >(argp2);
  result = (SbVec2s *) &(arg1)->setValue((SbVec2us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2b * >(argp2);
  result = (SbVec2s *) &(arg1)->setValue((SbVec2b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2s *) &(arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2s *) &(arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_setValue" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2s *) &(arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2s_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec2s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbVec2s_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2s::setValue(short const [2])\n"
    "    SbVec2s::setValue(short,short)\n"
    "    SbVec2s::setValue(SbVec2us const &)\n"
    "    SbVec2s::setValue(SbVec2b const &)\n"
    "    SbVec2s::setValue(SbVec2i32 const &)\n"
    "    SbVec2s::setValue(SbVec2f const &)\n"
    "    SbVec2s::setValue(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2s_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short temp2 ;
  int res2 = SWIG_TMPOBJ ;
  short temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_getValue" "', argument " "1"" of type '" "SbVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ((SbVec2s const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_short, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_short, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_dot" "', argument " "1"" of type '" "SbVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s_dot" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s_dot" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int32_t)((SbVec2s const *)arg1)->dot(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_negate" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___imul__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___imul__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2s___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2s___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2s___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2s___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2s::operator *=(int)\n"
    "    SbVec2s::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2s___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___itruediv__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___itruediv__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2s___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2s___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2s___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2s___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2s::operator /=(int)\n"
    "    SbVec2s::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2s___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___iadd__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___iadd__" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___iadd__" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec2s *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___isub__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___isub__" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___isub__" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec2s *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___neg__" "', argument " "1"" of type '" "SbVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = ((SbVec2s const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_toString" "', argument " "1"" of type '" "SbVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = ((SbVec2s const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_fromString" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s_output" "', argument " "1"" of type '" "SbVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec2s const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___add__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___add__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___add__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = SbVec2s___add__(arg1,(SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___sub__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___sub__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___sub__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = SbVec2s___sub__(arg1,(SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___mul__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec2s___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___rmul__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec2s___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___div__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec2s___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___truediv__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___truediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec2s___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___eq__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___eq__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___eq__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (int)SbVec2s___eq__(arg1,(SbVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2s___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___nq__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2s___nq__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2s___nq__" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (int)SbVec2s___nq__(arg1,(SbVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___getitem__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (short)SbVec2s___getitem__(arg1,arg2);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2s___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2s___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2s___setitem__" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2s___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2s___setitem__" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  SbVec2s___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec2s" "', argument " "1"" of type '" "SbVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec2s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec2s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec2s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec2f *)new SbVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec2f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec2f *)new SbVec2f((float const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec2f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec2f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec2f *)new SbVec2f(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (SbVec2f *)new SbVec2f((SbVec2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = (SbVec2f *)new SbVec2f((SbVec2b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = (SbVec2f *)new SbVec2f((SbVec2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2f" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = (SbVec2f *)new SbVec2f((SbVec2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec2f", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec2f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2f__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2f__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec2f__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbVec2f__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec2f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2f::SbVec2f()\n"
    "    SbVec2f::SbVec2f(float const [2])\n"
    "    SbVec2f::SbVec2f(float,float)\n"
    "    SbVec2f::SbVec2f(SbVec2d const &)\n"
    "    SbVec2f::SbVec2f(SbVec2b const &)\n"
    "    SbVec2f::SbVec2f(SbVec2s const &)\n"
    "    SbVec2f::SbVec2f(SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  {
    convert_SbVec2f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec2f *) &(arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbVec2f *) &(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2f *) &(arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2b * >(argp2);
  result = (SbVec2f *) &(arg1)->setValue((SbVec2b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbVec2f *) &(arg1)->setValue((SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_setValue" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2f *) &(arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2f_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2f_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2f_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec2f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbVec2f_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2f::setValue(float const [2])\n"
    "    SbVec2f::setValue(float,float)\n"
    "    SbVec2f::setValue(SbVec2d const &)\n"
    "    SbVec2f::setValue(SbVec2b const &)\n"
    "    SbVec2f::setValue(SbVec2s const &)\n"
    "    SbVec2f::setValue(SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_getValue" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ((SbVec2f const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_dot" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_dot" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_dot" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (float)((SbVec2f const *)arg1)->dot((SbVec2f const &)*arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_equals" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f_equals" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f_equals" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2f_equals" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)((SbVec2f const *)arg1)->equals((SbVec2f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_length" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (float)((SbVec2f const *)arg1)->length();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_sqrLength" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (float)((SbVec2f const *)arg1)->sqrLength();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_negate" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_normalize" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (float)(arg1)->normalize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___imul__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___imul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec2f *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___itruediv__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___itruediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec2f *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___iadd__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___iadd__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___iadd__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2f *) &(arg1)->operator +=((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___isub__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___isub__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___isub__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2f *) &(arg1)->operator -=((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___neg__" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = ((SbVec2f const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_toString" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = ((SbVec2f const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_fromString" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f_output" "', argument " "1"" of type '" "SbVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec2f const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___add__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___add__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___add__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = SbVec2f___add__(arg1,(SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___sub__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___sub__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___sub__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = SbVec2f___sub__(arg1,(SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___mul__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2f___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___rmul__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2f___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___div__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2f___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___truediv__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___truediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2f___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___eq__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___eq__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___eq__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (int)SbVec2f___eq__(arg1,(SbVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2f___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___nq__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2f___nq__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2f___nq__" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (int)SbVec2f___nq__(arg1,(SbVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___getitem__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SbVec2f___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2f___setitem__" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2f___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SbVec2f___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec2f" "', argument " "1"" of type '" "SbVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbTime__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbTime *)new SbTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTime__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SbTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbTime" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (SbTime *)new SbTime(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTime__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  long arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  SbTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbTime" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbTime" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  result = (SbTime *)new SbTime(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTime__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  timeval *arg1 = (timeval *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbTime *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_timeval, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbTime" "', argument " "1"" of type '" "timeval const *const""'"); 
  }
  arg1 = reinterpret_cast< timeval * >(argp1);
  result = (SbTime *)new SbTime((timeval const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbTime", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbTime__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_timeval, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbTime__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbTime__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbTime__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTime::SbTime()\n"
    "    SbTime::SbTime(double const)\n"
    "    SbTime::SbTime(int32_t const,long const)\n"
    "    SbTime::SbTime(timeval const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTime_getTimeOfDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_getTimeOfDay", 0, 0, 0)) SWIG_fail;
  result = SbTime::getTimeOfDay();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_setToTimeOfDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_setToTimeOfDay" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  (arg1)->setToTimeOfDay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_zero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_zero", 0, 0, 0)) SWIG_fail;
  result = SbTime::zero();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_max", 0, 0, 0)) SWIG_fail;
  result = SbTime::max();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_maxTime", 0, 0, 0)) SWIG_fail;
  result = SbTime::maxTime();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_sleep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SbTime_sleep" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SbTime::sleep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_setValue" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  int32_t arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_setValue" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbTime_setValue" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  timeval *arg2 = (timeval *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_setValue" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_timeval, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_setValue" "', argument " "2"" of type '" "timeval const *const""'"); 
  }
  arg2 = reinterpret_cast< timeval * >(argp2);
  (arg1)->setValue((timeval const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbTime_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_timeval, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbTime_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbTime_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbTime_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbTime_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTime::setValue(double const)\n"
    "    SbTime::setValue(int32_t const,long const)\n"
    "    SbTime::setValue(timeval const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTime_setMsecValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_setMsecValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_setMsecValue" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime_setMsecValue" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  (arg1)->setMsecValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_getValue" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  result = (double)((SbTime const *)arg1)->getValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  time_t *arg2 = 0 ;
  long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_getValue" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_time_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_getValue" "', argument " "2"" of type '" "time_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbTime_getValue" "', argument " "2"" of type '" "time_t &""'"); 
  }
  arg2 = reinterpret_cast< time_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_long,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbTime_getValue" "', argument " "3"" of type '" "long &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbTime_getValue" "', argument " "3"" of type '" "long &""'"); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  ((SbTime const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_getValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  timeval *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_getValue" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_timeval, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_getValue" "', argument " "2"" of type '" "timeval *""'"); 
  }
  arg2 = reinterpret_cast< timeval * >(argp2);
  ((SbTime const *)arg1)->getValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbTime_getValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbTime_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_timeval, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbTime_getValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_time_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbTime_getValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbTime_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTime::getValue() const\n"
    "    SbTime::getValue(time_t &,long &) const\n"
    "    SbTime::getValue(timeval *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTime_getMsecValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_getMsecValue" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  result = (unsigned long)((SbTime const *)arg1)->getMsecValue();
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_format__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_format" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_format" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = ((SbTime const *)arg1)->format((char const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_format__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_format" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  result = ((SbTime const *)arg1)->format();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_format(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbTime_format", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbTime_format__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbTime_format__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbTime_format'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTime::format(char const *const) const\n"
    "    SbTime::format() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTime_formatDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_formatDate" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_formatDate" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = ((SbTime const *)arg1)->formatDate((char const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_formatDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_formatDate" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  result = ((SbTime const *)arg1)->formatDate();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime_formatDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbTime_formatDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbTime_formatDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbTime_formatDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbTime_formatDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTime::formatDate(char const *const) const\n"
    "    SbTime::formatDate() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTime_parsedate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_parsedate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_parsedate" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTime_parsedate" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->parsedate((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___iadd__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbTime *) &(arg1)->operator +=((SbTime const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___isub__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbTime *) &(arg1)->operator -=((SbTime const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___neg__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  result = ((SbTime const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___imul__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbTime *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___itruediv__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbTime *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___truediv__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (double)((SbTime const *)arg1)->operator /((SbTime const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___mod__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___mod__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___mod__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = ((SbTime const *)arg1)->operator %((SbTime const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___eq__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SbTime const *)arg1)->operator ==((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___ne__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SbTime const *)arg1)->operator !=((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___lt__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SbTime const *)arg1)->operator <((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___gt__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SbTime const *)arg1)->operator >((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___le__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SbTime const *)arg1)->operator <=((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___ge__" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SbTime const *)arg1)->operator >=((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime_output" "', argument " "1"" of type '" "SbTime const *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbTime const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTime___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___add__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = SbTime___add__(arg1,(SbTime const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___sub__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = SbTime___sub__(arg1,(SbTime const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___mul__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbTime___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___rmul__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbTime___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbTime___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTime___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTime___div__" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTime___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbTime___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbTime" "', argument " "1"" of type '" "SbTime *""'"); 
  }
  arg1 = reinterpret_cast< SbTime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_getTypeId" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = ((SoEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoEvent", 0, 0, 0)) SWIG_fail;
  result = (SoEvent *)new SoEvent();
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEvent" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_isOfType" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEvent_isOfType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEvent_isOfType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoEvent const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_setTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbTime arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_setTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_setTime" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEvent_setTime" "', argument " "2"" of type '" "SbTime const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEvent_setTime" "', argument " "2"" of type '" "SbTime const""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setTime(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_getTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_getTime" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = ((SoEvent const *)arg1)->getTime();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_setPosition" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEvent_setPosition" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEvent_setPosition" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setPosition((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_getPosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_getPosition" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = (SbVec2s *) &((SoEvent const *)arg1)->getPosition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_getPosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_getPosition" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEvent_getPosition" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEvent_getPosition" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  result = (SbVec2s *) &((SoEvent const *)arg1)->getPosition((SbViewportRegion const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_getPosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEvent_getPosition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEvent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoEvent_getPosition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEvent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoEvent_getPosition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEvent_getPosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEvent::getPosition() const\n"
    "    SoEvent::getPosition(SbViewportRegion const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEvent_getNormalizedPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_getNormalizedPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_getNormalizedPosition" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEvent_getNormalizedPosition" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEvent_getNormalizedPosition" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  result = (SbVec2f *) &((SoEvent const *)arg1)->getNormalizedPosition((SbViewportRegion const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_setShiftDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_setShiftDown", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_setShiftDown" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEvent_setShiftDown" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setShiftDown(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_wasShiftDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_wasShiftDown" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = (SbBool)((SoEvent const *)arg1)->wasShiftDown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_setCtrlDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_setCtrlDown", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_setCtrlDown" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEvent_setCtrlDown" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCtrlDown(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_wasCtrlDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_wasCtrlDown" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = (SbBool)((SoEvent const *)arg1)->wasCtrlDown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_setAltDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEvent_setAltDown", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_setAltDown" "', argument " "1"" of type '" "SoEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEvent_setAltDown" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAltDown(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEvent_wasAltDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEvent_wasAltDown" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  result = (SbBool)((SoEvent const *)arg1)->wasAltDown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoNotRec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = (SoBase *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoNotRec" "', argument " "1"" of type '" "SoBase *const""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = (SoNotRec *)new SoNotRec(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotRec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  SoNotRec::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setType" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNotRec_setType" "', argument " "2"" of type '" "SoNotRec::Type""'");
  } 
  arg2 = static_cast< SoNotRec::Type >(val2);
  (arg1)->setType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getBase" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoBase *)((SoNotRec const *)arg1)->getBase();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getType" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoNotRec::Type)((SoNotRec const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getPrevious(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getPrevious" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoNotRec *)((SoNotRec const *)arg1)->getPrevious();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotRec, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setPrevious(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  SoNotRec *arg2 = (SoNotRec *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setPrevious", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setPrevious" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotRec_setPrevious" "', argument " "2"" of type '" "SoNotRec const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNotRec * >(argp2);
  (arg1)->setPrevious((SoNotRec const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  FILE *arg2 = (FILE *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_output" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoNotRec const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getOperationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec::OperationType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getOperationType" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoNotRec::OperationType)((SoNotRec const *)arg1)->getOperationType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getIndex" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (int)((SoNotRec const *)arg1)->getIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getFieldNumIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getFieldNumIndices" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (int)((SoNotRec const *)arg1)->getFieldNumIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getGroupChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getGroupChild" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoBase *)((SoNotRec const *)arg1)->getGroupChild();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_getGroupPrevChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_getGroupPrevChild" "', argument " "1"" of type '" "SoNotRec const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  result = (SoBase *)((SoNotRec const *)arg1)->getGroupPrevChild();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setOperationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  SoNotRec::OperationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setOperationType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setOperationType" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNotRec_setOperationType" "', argument " "2"" of type '" "SoNotRec::OperationType""'");
  } 
  arg2 = static_cast< SoNotRec::OperationType >(val2);
  (arg1)->setOperationType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setIndex" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNotRec_setIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setFieldNumIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setFieldNumIndices", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setFieldNumIndices" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNotRec_setFieldNumIndices" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFieldNumIndices(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setGroupChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  SoBase *arg2 = (SoBase *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setGroupChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setGroupChild" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotRec_setGroupChild" "', argument " "2"" of type '" "SoBase const *const""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  (arg1)->setGroupChild((SoBase const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotRec_setGroupPrevChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  SoBase *arg2 = (SoBase *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotRec_setGroupPrevChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotRec_setGroupPrevChild" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotRec_setGroupPrevChild" "', argument " "2"" of type '" "SoBase const *const""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  (arg1)->setGroupPrevChild((SoBase const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNotRec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotRec *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotRec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNotRec" "', argument " "1"" of type '" "SoNotRec *""'"); 
  }
  arg1 = reinterpret_cast< SoNotRec * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNotRec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNotRec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNotRec_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoNotList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoNotList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoNotList *)new SoNotList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNotList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoNotList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoNotList" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoNotList *)new SoNotList((SoNotList const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNotList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoNotList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoNotList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoNotList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoNotList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNotList::SoNotList()\n"
    "    SoNotList::SoNotList(SoNotList const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNotList_append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  SoNotRec *arg2 = (SoNotRec *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_append" "', argument " "1"" of type '" "SoNotList *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotList_append" "', argument " "2"" of type '" "SoNotRec *const""'"); 
  }
  arg2 = reinterpret_cast< SoNotRec * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  SoNotRec *arg2 = (SoNotRec *)0 ;
  SoField *arg3 = (SoField *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_append" "', argument " "1"" of type '" "SoNotList *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotList_append" "', argument " "2"" of type '" "SoNotRec *const""'"); 
  }
  arg2 = reinterpret_cast< SoNotRec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNotList_append" "', argument " "3"" of type '" "SoField *const""'"); 
  }
  arg3 = reinterpret_cast< SoField * >(argp3);
  (arg1)->append(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_append__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  SoNotRec *arg2 = (SoNotRec *)0 ;
  SoEngineOutput *arg3 = (SoEngineOutput *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_append" "', argument " "1"" of type '" "SoNotList *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotRec, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNotList_append" "', argument " "2"" of type '" "SoNotRec *const""'"); 
  }
  arg2 = reinterpret_cast< SoNotRec * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNotList_append" "', argument " "3"" of type '" "SoEngineOutput *const""'"); 
  }
  arg3 = reinterpret_cast< SoEngineOutput * >(argp3);
  (arg1)->append(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNotList_append", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNotRec, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNotList_append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNotRec, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoField, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNotList_append__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNotRec, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNotList_append__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNotList_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNotList::append(SoNotRec *const)\n"
    "    SoNotList::append(SoNotRec *const,SoField *const)\n"
    "    SoNotList::append(SoNotRec *const,SoEngineOutput *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNotList_setLastType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  SoNotRec::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNotList_setLastType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_setLastType" "', argument " "1"" of type '" "SoNotList *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNotList_setLastType" "', argument " "2"" of type '" "SoNotRec::Type""'");
  } 
  arg2 = static_cast< SoNotRec::Type >(val2);
  (arg1)->setLastType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getFirstRec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getFirstRec" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoNotRec *)((SoNotList const *)arg1)->getFirstRec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotRec, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getLastRec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getLastRec" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoNotRec *)((SoNotList const *)arg1)->getLastRec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotRec, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getFirstRecAtNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getFirstRecAtNode" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoNotRec *)((SoNotList const *)arg1)->getFirstRecAtNode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNotRec, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getLastField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getLastField" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoField *)((SoNotList const *)arg1)->getLastField();
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getLastEngineOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getLastEngineOutput" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SoEngineOutput *)((SoNotList const *)arg1)->getLastEngineOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_getTimeStamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_getTimeStamp" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  result = (SbUniqueId)((SoNotList const *)arg1)->getTimeStamp();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_output__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  FILE *arg2 = (FILE *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_output" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoNotList const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_output__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNotList_output" "', argument " "1"" of type '" "SoNotList const *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  ((SoNotList const *)arg1)->print();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNotList_output(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNotList_output", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoNotList_output__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNotList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNotList_output__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNotList_output'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNotList::print(FILE *const) const\n"
    "    SoNotList::print() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoNotList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNotList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNotList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNotList" "', argument " "1"" of type '" "SoNotList *""'"); 
  }
  arg1 = reinterpret_cast< SoNotList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNotList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNotList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNotList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SoField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoField" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_initClass", 0, 0, 0)) SWIG_fail;
  SoField::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_initClasses", 0, 0, 0)) SWIG_fail;
  SoField::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoField::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_setIgnored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_setIgnored", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_setIgnored" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_setIgnored" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setIgnored(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isIgnored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isIgnored" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isIgnored();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_setDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_setDefault", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_setDefault" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_setDefault" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDefault(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isDefault" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getTypeId" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = ((SoField const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoField::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isOfType" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_isOfType" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_isOfType" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoField const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_enableConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_enableConnection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_enableConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_enableConnection" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->enableConnection(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isConnectionEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isConnectionEnabled" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isConnectionEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_connectFrom" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoField_connectFrom" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SbBool)(arg1)->connectFrom(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_connectFrom" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->connectFrom(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  result = (SbBool)(arg1)->connectFrom(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_appendConnection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_appendConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_appendConnection" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_appendConnection" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->appendConnection(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_appendConnection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_appendConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_appendConnection" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  result = (SbBool)(arg1)->appendConnection(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_disconnect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_disconnect" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_disconnect" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  (arg1)->disconnect(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isConnectedFromEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isConnectedFromEngine" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isConnectedFromEngine();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getConnectedEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoEngineOutput **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_getConnectedEngine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getConnectedEngine" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoEngineOutput,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_getConnectedEngine" "', argument " "2"" of type '" "SoEngineOutput *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_getConnectedEngine" "', argument " "2"" of type '" "SoEngineOutput *&""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput ** >(argp2);
  result = (SbBool)((SoField const *)arg1)->getConnectedEngine(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_connectFrom" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoField_connectFrom" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SbBool)(arg1)->connectFrom(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_connectFrom" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->connectFrom(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_connectFrom" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)(arg1)->connectFrom(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_connectFrom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoField_connectFrom", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_connectFrom__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_connectFrom__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoField_connectFrom__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoField_connectFrom__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoField_connectFrom__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoField_connectFrom__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoField_connectFrom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoField::connectFrom(SoEngineOutput *,SbBool,SbBool)\n"
    "    SoField::connectFrom(SoEngineOutput *,SbBool)\n"
    "    SoField::connectFrom(SoEngineOutput *)\n"
    "    SoField::connectFrom(SoField *,SbBool,SbBool)\n"
    "    SoField::connectFrom(SoField *,SbBool)\n"
    "    SoField::connectFrom(SoField *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoField_appendConnection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_appendConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_appendConnection" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_appendConnection" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->appendConnection(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_appendConnection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_appendConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_appendConnection" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)(arg1)->appendConnection(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_appendConnection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoField_appendConnection", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_appendConnection__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_appendConnection__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoField_appendConnection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoField_appendConnection__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoField_appendConnection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoField::appendConnection(SoEngineOutput *,SbBool)\n"
    "    SoField::appendConnection(SoEngineOutput *)\n"
    "    SoField::appendConnection(SoField *,SbBool)\n"
    "    SoField::appendConnection(SoField *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoField_disconnect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_disconnect" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_disconnect" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->disconnect(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isConnectedFromField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isConnectedFromField" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isConnectedFromField();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getConnectedField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_getConnectedField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getConnectedField" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_getConnectedField" "', argument " "2"" of type '" "SoField *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_getConnectedField" "', argument " "2"" of type '" "SoField *&""'"); 
  }
  arg2 = reinterpret_cast< SoField ** >(argp2);
  result = (SbBool)((SoField const *)arg1)->getConnectedField(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getNumConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getNumConnections" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (int)((SoField const *)arg1)->getNumConnections();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getForwardConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_getForwardConnections", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getForwardConnections" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoField const *)arg1)->getForwardConnections(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_getConnections", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getConnections" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_getConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_getConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoField const *)arg1)->getConnections(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_disconnect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_disconnect" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  (arg1)->disconnect();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_disconnect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoField_disconnect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoField_disconnect__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_disconnect__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoField_disconnect__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoField_disconnect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoField::disconnect(SoEngineOutput *)\n"
    "    SoField::disconnect(SoField *)\n"
    "    SoField::disconnect()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoField_isConnected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isConnected" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isConnected();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_setContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_setContainer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_setContainer" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_setContainer" "', argument " "2"" of type '" "SoFieldContainer *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  (arg1)->setContainer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getContainer" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SoFieldContainer *)((SoField const *)arg1)->getContainer();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_set" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->set((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_shouldWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_shouldWrite" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->shouldWrite();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_touch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_touch" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  (arg1)->touch();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_startNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_startNotify" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  (arg1)->startNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_notify" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_enableNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_enableNotify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_enableNotify" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_enableNotify" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbBool)(arg1)->enableNotify(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isNotifyEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isNotifyEnabled" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isNotifyEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_addAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *arg2 = 0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_addAuditor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_addAuditor" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_addAuditor" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_addAuditor" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->addAuditor(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_removeAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *arg2 = 0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_removeAuditor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_removeAuditor" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_removeAuditor" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoField_removeAuditor" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->removeAuditor(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField___eq__" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField___eq__" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField___eq__" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (int)((SoField const *)arg1)->operator ==((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoField___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField___ne__" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField___ne__" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField___ne__" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (int)((SoField const *)arg1)->operator !=((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoField_connectionStatusChanged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_connectionStatusChanged", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_connectionStatusChanged" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_connectionStatusChanged" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->connectionStatusChanged(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isReadOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isReadOnly" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->isReadOnly();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_isSame" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoField const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_copyFrom" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoField_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_fixCopy" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_referencesCopy" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_copyConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_copyConnection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_copyConnection" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_copyConnection" "', argument " "2"" of type '" "SoField const *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyConnection((SoField const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_read", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_read" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_read" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)(arg1)->read(arg2,(SbName const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_write", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_write" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_write" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  ((SoField const *)arg1)->write(arg2,(SbName const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_countWriteRefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_countWriteRefs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_countWriteRefs" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoField_countWriteRefs" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  ((SoField const *)arg1)->countWriteRefs(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_setFieldType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_setFieldType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_setFieldType" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_setFieldType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFieldType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getFieldType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getFieldType" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (int)((SoField const *)arg1)->getFieldType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_getDirty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_getDirty" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = (SbBool)((SoField const *)arg1)->getDirty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_setDirty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoField_setDirty", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_setDirty" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoField_setDirty" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDirty(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_evaluate" "', argument " "1"" of type '" "SoField const *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  ((SoField const *)arg1)->evaluate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoField_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoField_get" "', argument " "1"" of type '" "SoField *""'"); 
  }
  arg1 = reinterpret_cast< SoField * >(argp1);
  result = SoField_get(arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoField, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SoSField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSField" "', argument " "1"" of type '" "SoSField *""'"); 
  }
  arg1 = reinterpret_cast< SoSField * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSField_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSField_initClass", 0, 0, 0)) SWIG_fail;
  SoSField::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSField_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSField_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSField::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSField_atexit_cleanup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSField_atexit_cleanup", 0, 0, 0)) SWIG_fail;
  SoSField::atexit_cleanup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSField, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SoMField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMField" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMField::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_atexit_cleanup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_atexit_cleanup", 0, 0, 0)) SWIG_fail;
  SoMField::atexit_cleanup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_getNum" "', argument " "1"" of type '" "SoMField const *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  result = (int)((SoMField const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_setNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_setNum", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_setNum" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_setNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_deleteValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_deleteValues" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMField_deleteValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->deleteValues(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_deleteValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_deleteValues" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deleteValues(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_deleteValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMField_deleteValues", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMField_deleteValues__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMField_deleteValues__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMField_deleteValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMField::deleteValues(int,int)\n"
    "    SoMField::deleteValues(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMField_insertSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_insertSpace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_insertSpace" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_insertSpace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMField_insertSpace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertSpace(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_set1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  char *arg3 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_set1", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_set1" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_set1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMField_set1" "', argument " "3"" of type '" "char const *const""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (SbBool)(arg1)->set1(arg2,(char const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_initClass", 0, 0, 0)) SWIG_fail;
  SoMField::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_enableDeleteValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_enableDeleteValues" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  (arg1)->enableDeleteValues();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_isDeleteValuesEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_isDeleteValuesEnabled" "', argument " "1"" of type '" "SoMField const *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  result = (SbBool)((SoMField const *)arg1)->isDeleteValuesEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField___len__" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  result = (int)SoMField___len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMField_get1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMField *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMField_get1", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMField_get1" "', argument " "1"" of type '" "SoMField *""'"); 
  }
  arg1 = reinterpret_cast< SoMField * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMField_get1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = SoMField_get1(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMField_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMField, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoAuditorList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAuditorList", 0, 0, 0)) SWIG_fail;
  result = (SoAuditorList *)new SoAuditorList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAuditorList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoAuditorList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoAuditorList" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_append", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_append" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAuditorList_append" "', argument " "2"" of type '" "void *const""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAuditorList_append" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->append(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  int arg2 ;
  void *arg3 = (void *)0 ;
  SoNotRec::Type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_set" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAuditorList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoAuditorList_set" "', argument " "3"" of type '" "void *const""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoAuditorList_set" "', argument " "4"" of type '" "SoNotRec::Type""'");
  } 
  arg4 = static_cast< SoNotRec::Type >(val4);
  (arg1)->set(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_getObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_getObject", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_getObject" "', argument " "1"" of type '" "SoAuditorList const *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAuditorList_getObject" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void *)((SoAuditorList const *)arg1)->getObject(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNotRec::Type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_getType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_getType" "', argument " "1"" of type '" "SoAuditorList const *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAuditorList_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNotRec::Type)((SoAuditorList const *)arg1)->getType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_getLength" "', argument " "1"" of type '" "SoAuditorList const *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  result = (int)((SoAuditorList const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_find", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_find" "', argument " "1"" of type '" "SoAuditorList const *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAuditorList_find" "', argument " "2"" of type '" "void *const""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAuditorList_find" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  result = (int)((SoAuditorList const *)arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_remove__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_remove" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAuditorList_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_remove__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_remove" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAuditorList_remove" "', argument " "2"" of type '" "void *const""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAuditorList_remove" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->remove(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAuditorList_remove", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAuditorList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAuditorList_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAuditorList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoAuditorList_remove__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAuditorList_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAuditorList::remove(int const)\n"
    "    SoAuditorList::remove(void *const,SoNotRec::Type const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoAuditorList_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAuditorList *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAuditorList_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAuditorList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAuditorList_notify" "', argument " "1"" of type '" "SoAuditorList *""'"); 
  }
  arg1 = reinterpret_cast< SoAuditorList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAuditorList_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAuditorList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAuditorList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAuditorList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBase_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_initClass", 0, 0, 0)) SWIG_fail;
  SoBase::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_ref" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  ((SoBase const *)arg1)->ref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_unref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_unref" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  ((SoBase const *)arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_unrefNoDelete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_unrefNoDelete" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  ((SoBase const *)arg1)->unrefNoDelete();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getRefCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_getRefCount" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = (int32_t)((SoBase const *)arg1)->getRefCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_touch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_touch" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  (arg1)->touch();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_getTypeId" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = ((SoBase const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_isOfType" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_isOfType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_isOfType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoBase const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBase::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_getName" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = ((SoBase const *)arg1)->getName();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_setName" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setName((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_addName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = (SoBase *)0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_addName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_addName" "', argument " "1"" of type '" "SoBase *const""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_addName" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoBase::addName(arg1,(char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_removeName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = (SoBase *)0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_removeName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_removeName" "', argument " "1"" of type '" "SoBase *const""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_removeName" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoBase::removeName(arg1,(char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_startNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_startNotify" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  (arg1)->startNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_notify" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_addAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_addAuditor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_addAuditor" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_addAuditor" "', argument " "2"" of type '" "void *const""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBase_addAuditor" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->addAuditor(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_removeAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  SoNotRec::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_removeAuditor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_removeAuditor" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_removeAuditor" "', argument " "2"" of type '" "void *const""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBase_removeAuditor" "', argument " "3"" of type '" "SoNotRec::Type""'");
  } 
  arg3 = static_cast< SoNotRec::Type >(val3);
  (arg1)->removeAuditor(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getAuditors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAuditorList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_getAuditors" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = (SoAuditorList *) &((SoBase const *)arg1)->getAuditors();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAuditorList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_addWriteReference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_addWriteReference" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBase_addWriteReference" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->addWriteReference(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_addWriteReference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_addWriteReference" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->addWriteReference(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_addWriteReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoBase_addWriteReference", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBase_addWriteReference__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoBase_addWriteReference__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoBase_addWriteReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBase::addWriteReference(SoOutput *,SbBool)\n"
    "    SoBase::addWriteReference(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoBase_shouldWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_shouldWrite" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = (SbBool)(arg1)->shouldWrite();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_incrementCurrentWriteCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_incrementCurrentWriteCounter", 0, 0, 0)) SWIG_fail;
  SoBase::incrementCurrentWriteCounter();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_decrementCurrentWriteCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_decrementCurrentWriteCounter", 0, 0, 0)) SWIG_fail;
  SoBase::decrementCurrentWriteCounter();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getNamedBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoType arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_getNamedBase", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_getNamedBase" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_getNamedBase" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SoBase *)SoBase::getNamedBase((SbName const &)*arg1,SWIG_STD_MOVE(arg2));
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getNamedBases(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoBaseList *arg2 = 0 ;
  SoType arg3 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_getNamedBases", 3, 3, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoBaseList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_getNamedBases" "', argument " "2"" of type '" "SoBaseList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_getNamedBases" "', argument " "2"" of type '" "SoBaseList &""'"); 
  }
  arg2 = reinterpret_cast< SoBaseList * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBase_getNamedBases" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_getNamedBases" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (int)SoBase::getNamedBases((SbName const &)*arg1,*arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoBase **arg2 = 0 ;
  SoType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_read", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBase_read" "', argument " "2"" of type '" "SoBase *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_read" "', argument " "2"" of type '" "SoBase *&""'"); 
  }
  arg2 = reinterpret_cast< SoBase ** >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBase_read" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBase_read" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (SbBool)SoBase::read(arg1,*arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_setInstancePrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  SoBase::setInstancePrefix((SbString const &)*arg1);
  resultobj = SWIG_Py_Void();
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_setTraceRefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoBase_setTraceRefs" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoBase::setTraceRefs(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_getTraceRefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_getTraceRefs", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoBase::getTraceRefs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_connectRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbName *arg4 = 0 ;
  SbName *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[5] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBase_connectRoute", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_connectRoute" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[4]))
    {
      arg5 = new SbName(PyBytes_AsString(swig_obj[4]));
    }
    else if  (PyUnicode_Check(swig_obj[4])){
      arg5 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[4], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg5 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[4], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg5 = *tmp;
    }
  }
  result = (SbBool)SoBase::connectRoute(arg1,(SbName const &)*arg2,(SbName const &)*arg3,(SbName const &)*arg4,(SbName const &)*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_assertAlive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_assertAlive" "', argument " "1"" of type '" "SoBase const *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  ((SoBase const *)arg1)->assertAlive();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase_readRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase_readRoute" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)SoBase::readRoute(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoBase" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  delete_SoBase(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBase___hash__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBase___hash__" "', argument " "1"" of type '" "SoBase *""'"); 
  }
  arg1 = reinterpret_cast< SoBase * >(argp1);
  result = SoBase___hash__(arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoBaseList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoBaseList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoBaseList *)new SoBaseList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBaseList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoBaseList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoBaseList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoBaseList *)new SoBaseList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBaseList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoBaseList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoBaseList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoBaseList" "', argument " "1"" of type '" "SoBaseList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoBaseList" "', argument " "1"" of type '" "SoBaseList const &""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  result = (SoBaseList *)new SoBaseList((SoBaseList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBaseList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoBaseList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoBaseList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoBaseList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoBaseList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoBaseList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoBaseList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBaseList::SoBaseList()\n"
    "    SoBaseList::SoBaseList(int const)\n"
    "    SoBaseList::SoBaseList(SoBaseList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoBaseList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoBaseList" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_append" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseList_append" "', argument " "2"" of type '" "SoBase *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_insert" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseList_insert" "', argument " "2"" of type '" "SoBase *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_remove" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_removeItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_removeItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_removeItem" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseList_removeItem" "', argument " "2"" of type '" "SoBase *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  (arg1)->removeItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_truncate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_truncate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_truncate" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  SoBaseList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_copy" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoBaseList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseList_copy" "', argument " "2"" of type '" "SoBaseList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBaseList_copy" "', argument " "2"" of type '" "SoBaseList const &""'"); 
  }
  arg2 = reinterpret_cast< SoBaseList * >(argp2);
  (arg1)->copy((SoBaseList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  SoBase *arg3 = (SoBase *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_set" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBaseList_set" "', argument " "3"" of type '" "SoBase *const""'"); 
  }
  arg3 = reinterpret_cast< SoBase * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_addReferences(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_addReferences", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_addReferences" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList_addReferences" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->addReferences(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_isReferencing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_isReferencing" "', argument " "1"" of type '" "SoBaseList const *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  result = (SbBool)((SoBaseList const *)arg1)->isReferencing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  SoBase *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList___setitem__" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBaseList___setitem__" "', argument " "3"" of type '" "SoBase *""'"); 
  }
  arg3 = reinterpret_cast< SoBase * >(argp3);
  SoBaseList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList___getitem__" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoBase *)SoBaseList___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseList_get" "', argument " "1"" of type '" "SoBaseList *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBaseList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoBase *)SoBaseList_get(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBaseList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBaseList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBaseList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoNodeList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoNodeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoNodeList *)new SoNodeList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoNodeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoNodeList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoNodeList *)new SoNodeList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoNodeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoNodeList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoNodeList" "', argument " "1"" of type '" "SoNodeList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoNodeList" "', argument " "1"" of type '" "SoNodeList const &""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  result = (SoNodeList *)new SoNodeList((SoNodeList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoNodeList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoNodeList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoNodeList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoNodeList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoNodeList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoNodeList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodeList::SoNodeList()\n"
    "    SoNodeList::SoNodeList(int const)\n"
    "    SoNodeList::SoNodeList(SoNodeList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoNodeList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNodeList" "', argument " "1"" of type '" "SoNodeList *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeList_append" "', argument " "1"" of type '" "SoNodeList *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeList_append" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeList___setitem__" "', argument " "1"" of type '" "SoNodeList *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodeList___setitem__" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  SoNodeList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeList___getitem__" "', argument " "1"" of type '" "SoNodeList *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)SoNodeList___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeList_get" "', argument " "1"" of type '" "SoNodeList *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)SoNodeList_get(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodeList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoDetailList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoDetailList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoDetailList *)new SoDetailList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetailList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDetailList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoDetailList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoDetailList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoDetailList *)new SoDetailList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetailList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDetailList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoDetailList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoDetailList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoDetailList" "', argument " "1"" of type '" "SoDetailList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoDetailList" "', argument " "1"" of type '" "SoDetailList const &""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  result = (SoDetailList *)new SoDetailList((SoDetailList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetailList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDetailList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoDetailList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoDetailList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoDetailList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoDetailList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoDetailList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoDetailList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDetailList::SoDetailList()\n"
    "    SoDetailList::SoDetailList(int const)\n"
    "    SoDetailList::SoDetailList(SoDetailList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoDetailList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDetailList" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  SoDetail *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_append" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDetailList_append" "', argument " "2"" of type '" "SoDetail *""'"); 
  }
  arg2 = reinterpret_cast< SoDetail * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  SoDetail *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_insert" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDetailList_insert" "', argument " "2"" of type '" "SoDetail *""'"); 
  }
  arg2 = reinterpret_cast< SoDetail * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDetailList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_truncate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_truncate" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDetailList_truncate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->truncate(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_truncate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_truncate" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_truncate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDetailList_truncate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDetailList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoDetailList_truncate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDetailList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoDetailList_truncate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDetailList_truncate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDetailList::truncate(int const,int const)\n"
    "    SoDetailList::truncate(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDetailList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  SoDetailList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_copy" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoDetailList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDetailList_copy" "', argument " "2"" of type '" "SoDetailList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDetailList_copy" "', argument " "2"" of type '" "SoDetailList const &""'"); 
  }
  arg2 = reinterpret_cast< SoDetailList * >(argp2);
  (arg1)->copy((SoDetailList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  SoDetail *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_set" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDetailList_set" "', argument " "3"" of type '" "SoDetail *""'"); 
  }
  arg3 = reinterpret_cast< SoDetail * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  SoDetail *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList___setitem__" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDetailList___setitem__" "', argument " "3"" of type '" "SoDetail *""'"); 
  }
  arg3 = reinterpret_cast< SoDetail * >(argp3);
  SoDetailList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList___getitem__" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoDetail *)SoDetailList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetailList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetailList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetailList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetailList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetailList_get" "', argument " "1"" of type '" "SoDetailList *""'"); 
  }
  arg1 = reinterpret_cast< SoDetailList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDetailList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoDetail *)SoDetailList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDetailList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDetailList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDetailList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTypeList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoTypeList *)new SoTypeList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTypeList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoTypeList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoTypeList *)new SoTypeList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTypeList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoTypeList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTypeList" "', argument " "1"" of type '" "SoTypeList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoTypeList" "', argument " "1"" of type '" "SoTypeList const &""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  result = (SoTypeList *)new SoTypeList((SoTypeList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTypeList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoTypeList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoTypeList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoTypeList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoTypeList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoTypeList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoTypeList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTypeList::SoTypeList()\n"
    "    SoTypeList::SoTypeList(int const)\n"
    "    SoTypeList::SoTypeList(SoTypeList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTypeList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList_append" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTypeList_append" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTypeList_append" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->append(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList_find" "', argument " "1"" of type '" "SoTypeList const *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTypeList_find" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTypeList_find" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)((SoTypeList const *)arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  SoType arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList_insert" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTypeList_insert" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTypeList_insert" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTypeList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  int arg2 ;
  SoType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList_set" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTypeList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTypeList_set" "', argument " "3"" of type '" "SoType const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTypeList_set" "', argument " "3"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  int arg2 ;
  SoType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList___setitem__" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTypeList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTypeList___setitem__" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTypeList___setitem__" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  SoTypeList___setitem__(arg1,arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList___getitem__" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTypeList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = SoTypeList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTypeList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTypeList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTypeList_get" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTypeList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = SoTypeList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTypeList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTypeList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTypeList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTypeList" "', argument " "1"" of type '" "SoTypeList *""'"); 
  }
  arg1 = reinterpret_cast< SoTypeList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTypeList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTypeList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTypeList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoEnabledElementsList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnabledElementsList *arg1 = (SoEnabledElementsList *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEnabledElementsList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnabledElementsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoEnabledElementsList" "', argument " "1"" of type '" "SoEnabledElementsList *const""'"); 
  }
  arg1 = reinterpret_cast< SoEnabledElementsList * >(argp1);
  result = (SoEnabledElementsList *)new SoEnabledElementsList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEnabledElementsList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoEnabledElementsList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnabledElementsList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnabledElementsList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEnabledElementsList" "', argument " "1"" of type '" "SoEnabledElementsList *""'"); 
  }
  arg1 = reinterpret_cast< SoEnabledElementsList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnabledElementsList_getElements(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnabledElementsList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnabledElementsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnabledElementsList_getElements" "', argument " "1"" of type '" "SoEnabledElementsList const *""'"); 
  }
  arg1 = reinterpret_cast< SoEnabledElementsList * >(argp1);
  result = (SoTypeList *) &((SoEnabledElementsList const *)arg1)->getElements();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnabledElementsList_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnabledElementsList *arg1 = 0 ;
  SoType arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnabledElementsList_enable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnabledElementsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnabledElementsList_enable" "', argument " "1"" of type '" "SoEnabledElementsList *""'"); 
  }
  arg1 = reinterpret_cast< SoEnabledElementsList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnabledElementsList_enable" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnabledElementsList_enable" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEnabledElementsList_enable" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->enable(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnabledElementsList_merge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnabledElementsList *arg1 = 0 ;
  SoEnabledElementsList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnabledElementsList_merge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnabledElementsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnabledElementsList_merge" "', argument " "1"" of type '" "SoEnabledElementsList *""'"); 
  }
  arg1 = reinterpret_cast< SoEnabledElementsList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoEnabledElementsList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnabledElementsList_merge" "', argument " "2"" of type '" "SoEnabledElementsList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnabledElementsList_merge" "', argument " "2"" of type '" "SoEnabledElementsList const &""'"); 
  }
  arg2 = reinterpret_cast< SoEnabledElementsList * >(argp2);
  (arg1)->merge((SoEnabledElementsList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnabledElementsList_getCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnabledElementsList_getCounter", 0, 0, 0)) SWIG_fail;
  result = (int)SoEnabledElementsList::getCounter();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEnabledElementsList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEnabledElementsList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEnabledElementsList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoEngineOutputList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoEngineOutputList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoEngineOutputList *)new SoEngineOutputList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoEngineOutputList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoEngineOutputList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoEngineOutputList *)new SoEngineOutputList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoEngineOutputList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoEngineOutputList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoEngineOutputList" "', argument " "1"" of type '" "SoEngineOutputList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoEngineOutputList" "', argument " "1"" of type '" "SoEngineOutputList const &""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  result = (SoEngineOutputList *)new SoEngineOutputList((SoEngineOutputList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoEngineOutputList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoEngineOutputList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoEngineOutputList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoEngineOutputList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoEngineOutputList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoEngineOutputList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineOutputList::SoEngineOutputList()\n"
    "    SoEngineOutputList::SoEngineOutputList(int const)\n"
    "    SoEngineOutputList::SoEngineOutputList(SoEngineOutputList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList_append" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputList_append" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList_insert" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputList_insert" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEngineOutputList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  int arg2 ;
  SoEngineOutput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList_set" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputList_set" "', argument " "3"" of type '" "SoEngineOutput *""'"); 
  }
  arg3 = reinterpret_cast< SoEngineOutput * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  int arg2 ;
  SoEngineOutput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList___setitem__" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputList___setitem__" "', argument " "3"" of type '" "SoEngineOutput *""'"); 
  }
  arg3 = reinterpret_cast< SoEngineOutput * >(argp3);
  SoEngineOutputList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList___getitem__" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoEngineOutput *)SoEngineOutputList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputList_get" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoEngineOutput *)SoEngineOutputList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoEngineOutputList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEngineOutputList" "', argument " "1"" of type '" "SoEngineOutputList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEngineOutputList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEngineOutputList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEngineOutputList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoEngineList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoEngineList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoEngineList *)new SoEngineList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoEngineList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoEngineList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoEngineList *)new SoEngineList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoEngineList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoEngineList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoEngineList" "', argument " "1"" of type '" "SoEngineList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoEngineList" "', argument " "1"" of type '" "SoEngineList const &""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  result = (SoEngineList *)new SoEngineList((SoEngineList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoEngineList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoEngineList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoEngineList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoEngineList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoEngineList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoEngineList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineList::SoEngineList()\n"
    "    SoEngineList::SoEngineList(int const)\n"
    "    SoEngineList::SoEngineList(SoEngineList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoEngineList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEngineList" "', argument " "1"" of type '" "SoEngineList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  SoEngine *arg2 = (SoEngine *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineList_append" "', argument " "1"" of type '" "SoEngineList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineList_append" "', argument " "2"" of type '" "SoEngine *const""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  int arg2 ;
  SoEngine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineList___setitem__" "', argument " "1"" of type '" "SoEngineList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineList___setitem__" "', argument " "3"" of type '" "SoEngine *""'"); 
  }
  arg3 = reinterpret_cast< SoEngine * >(argp3);
  SoEngineList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineList___getitem__" "', argument " "1"" of type '" "SoEngineList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoEngine *)SoEngineList___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineList_get" "', argument " "1"" of type '" "SoEngineList *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoEngine *)SoEngineList_get(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEngineList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEngineList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEngineList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoFieldList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoFieldList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoFieldList *)new SoFieldList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoFieldList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoFieldList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoFieldList *)new SoFieldList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoFieldList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoFieldList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoFieldList" "', argument " "1"" of type '" "SoFieldList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoFieldList" "', argument " "1"" of type '" "SoFieldList const &""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  result = (SoFieldList *)new SoFieldList((SoFieldList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoFieldList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoFieldList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoFieldList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoFieldList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoFieldList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoFieldList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldList::SoFieldList()\n"
    "    SoFieldList::SoFieldList(int const)\n"
    "    SoFieldList::SoFieldList(SoFieldList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList_append" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldList_append" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  SoField *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList_insert" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldList_insert" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFieldList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  int arg2 ;
  SoField *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList_set" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldList_set" "', argument " "3"" of type '" "SoField *""'"); 
  }
  arg3 = reinterpret_cast< SoField * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList_get" "', argument " "1"" of type '" "SoFieldList const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoField *)((SoFieldList const *)arg1)->get(arg2);
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  int arg2 ;
  SoField *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList___setitem__" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldList___setitem__" "', argument " "3"" of type '" "SoField *""'"); 
  }
  arg3 = reinterpret_cast< SoField * >(argp3);
  SoFieldList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList___getitem__" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoField *)SoFieldList___getitem__(arg1,arg2);
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoField *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldList_get" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoField *)SoFieldList_get__SWIG_1(arg1,arg2);
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldList_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldList_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoFieldList_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoFieldList_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldList_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldList::get(int const) const\n"
    "    SoFieldList::get(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoFieldList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoFieldList" "', argument " "1"" of type '" "SoFieldList *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFieldList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFieldList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFieldList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPathList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoPathList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoPathList *)new SoPathList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoPathList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoPathList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoPathList *)new SoPathList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPathList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPathList" "', argument " "1"" of type '" "SoPathList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPathList" "', argument " "1"" of type '" "SoPathList const &""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  result = (SoPathList *)new SoPathList((SoPathList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPathList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoPathList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPathList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoPathList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPathList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPathList::SoPathList()\n"
    "    SoPathList::SoPathList(int const)\n"
    "    SoPathList::SoPathList(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoPathList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPathList" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList_append" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathList_append" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList_findPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathList_findPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList_findPath" "', argument " "1"" of type '" "SoPathList const *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathList_findPath" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPathList_findPath" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (int)((SoPathList const *)arg1)->findPath((SoPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList_sort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList_sort" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  (arg1)->sort();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList_uniquify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList_uniquify" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  (arg1)->uniquify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  int arg2 ;
  SoPath *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList___setitem__" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPathList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPathList___setitem__" "', argument " "3"" of type '" "SoPath *""'"); 
  }
  arg3 = reinterpret_cast< SoPath * >(argp3);
  SoPathList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList___getitem__" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPathList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPath *)SoPathList___getitem__(arg1,arg2);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathList_get" "', argument " "1"" of type '" "SoPathList *""'"); 
  }
  arg1 = reinterpret_cast< SoPathList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPathList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPath *)SoPathList_get(arg1,arg2);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPathList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPathList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPathList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPickedPointList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoPickedPointList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoPickedPointList *)new SoPickedPointList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPointList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickedPointList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoPickedPointList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoPickedPointList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoPickedPointList *)new SoPickedPointList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPointList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickedPointList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPickedPointList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoPickedPointList,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPickedPointList" "', argument " "1"" of type '" "SoPickedPointList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPickedPointList" "', argument " "1"" of type '" "SoPickedPointList const &""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  result = (SoPickedPointList *)new SoPickedPointList((SoPickedPointList const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPointList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickedPointList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPickedPointList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoPickedPointList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoPickedPointList, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPickedPointList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoPickedPointList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPickedPointList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPointList::SoPickedPointList()\n"
    "    SoPickedPointList::SoPickedPointList(int const)\n"
    "    SoPickedPointList::SoPickedPointList(SoPickedPointList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoPickedPointList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPickedPointList" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  SoPickedPoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_append" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPointList_append" "', argument " "2"" of type '" "SoPickedPoint *""'"); 
  }
  arg2 = reinterpret_cast< SoPickedPoint * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  SoPickedPoint *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_insert" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPointList_insert" "', argument " "2"" of type '" "SoPickedPoint *""'"); 
  }
  arg2 = reinterpret_cast< SoPickedPoint * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPickedPointList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_truncate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_truncate" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPickedPointList_truncate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->truncate(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_truncate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_truncate" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_truncate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPointList_truncate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPointList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPickedPointList_truncate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPointList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoPickedPointList_truncate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPointList_truncate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPointList::truncate(int const,int const)\n"
    "    SoPickedPointList::truncate(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  SoPickedPoint *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_set" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPickedPointList_set" "', argument " "3"" of type '" "SoPickedPoint *""'"); 
  }
  arg3 = reinterpret_cast< SoPickedPoint * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  SoPickedPoint *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList___setitem__" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPickedPointList___setitem__" "', argument " "3"" of type '" "SoPickedPoint *""'"); 
  }
  arg3 = reinterpret_cast< SoPickedPoint * >(argp3);
  SoPickedPointList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList___getitem__" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPickedPoint *)SoPickedPointList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPointList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPointList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPointList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPointList_get" "', argument " "1"" of type '" "SoPickedPointList *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPointList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPointList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPickedPoint *)SoPickedPointList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickedPointList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickedPointList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPickedPointList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPath_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_initClass", 0, 0, 0)) SWIG_fail;
  SoPath::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoPath" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoPath *)new SoPath(arg1);
  {
    resultobj = autocast_path(result);
  }
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoPath *)new SoPath();
  {
    resultobj = autocast_path(result);
  }
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPath__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPath" "', argument " "1"" of type '" "SoNode *const""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoPath *)new SoPath(arg1);
  {
    resultobj = autocast_path(result);
  }
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPath__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoPath,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPath" "', argument " "1"" of type '" "SoPath const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPath" "', argument " "1"" of type '" "SoPath const &""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (SoPath *)new SoPath((SoPath const &)*arg1);
  {
    resultobj = autocast_path(result);
  }
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPath", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoPath__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPath__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoPath, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPath__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoPath__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPath::SoPath(int const)\n"
    "    SoPath::SoPath()\n"
    "    SoPath::SoPath(SoNode *const)\n"
    "    SoPath::SoPath(SoPath const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPath_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPath::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getTypeId" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = ((SoPath const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_setHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_setHead", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_setHead" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_setHead" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setHead(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getHead" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (SoNode *)((SoPath const *)arg1)->getHead();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_append" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_append" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_append" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_append__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_append" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_append" "', argument " "2"" of type '" "SoPath const *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->append((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPath_append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPath_append__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPath_append__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPath_append__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPath_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPath::append(int const)\n"
    "    SoPath::append(SoNode *const)\n"
    "    SoPath::append(SoPath const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPath_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_push" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_push" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_pop" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  (arg1)->pop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getTail" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (SoNode *)((SoPath const *)arg1)->getTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_getNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getNode" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_getNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoPath const *)arg1)->getNode(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getNodeFromTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_getNodeFromTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getNodeFromTail" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_getNodeFromTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoPath const *)arg1)->getNodeFromTail(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_getIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getIndex" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_getIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoPath const *)arg1)->getIndex(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getIndexFromTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_getIndexFromTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getIndexFromTail" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_getIndexFromTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoPath const *)arg1)->getIndexFromTail(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_getLength" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (int)((SoPath const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_truncate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_truncate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_truncate" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_findFork(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_findFork", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_findFork" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_findFork" "', argument " "2"" of type '" "SoPath const *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (int)((SoPath const *)arg1)->findFork((SoPath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_findNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_findNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_findNode" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_findNode" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoPath const *)arg1)->findNode((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_containsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_containsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_containsNode" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_containsNode" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbBool)((SoPath const *)arg1)->containsNode((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_containsPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_containsPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_containsPath" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_containsPath" "', argument " "2"" of type '" "SoPath const *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)((SoPath const *)arg1)->containsPath((SoPath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_copy" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPath_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoPath *)((SoPath const *)arg1)->copy(arg2,arg3);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_copy" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPath_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPath *)((SoPath const *)arg1)->copy(arg2);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_copy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_copy" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (SoPath *)((SoPath const *)arg1)->copy();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPath_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPath_copy__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPath_copy__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoPath_copy__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPath_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPath::copy(int const,int) const\n"
    "    SoPath::copy(int const) const\n"
    "    SoPath::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPath_getByName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  SoPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  result = (SoPath *)SoPath::getByName(SWIG_STD_MOVE(arg1));
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getByName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  SoPathList *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_getByName" "', argument " "2"" of type '" "SoPathList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPath_getByName" "', argument " "2"" of type '" "SoPathList &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  result = (int)SoPath::getByName(SWIG_STD_MOVE(arg1),*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_getByName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPath_getByName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      
      // http://stackoverflow.com/questions/2807887/cs-char-by-swig-got-problem-in-python-3-0
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_SoPath_getByName__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      
      // http://stackoverflow.com/questions/2807887/cs-char-by-swig-got-problem-in-python-3-0
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPath_getByName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPath_getByName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPath::getByName(SbName const)\n"
    "    SoPath::getByName(SbName const,SoPathList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPath_insertIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_insertIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_insertIndex" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_insertIndex" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPath_insertIndex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertIndex(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_removeIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_removeIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_removeIndex" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_removeIndex" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPath_removeIndex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->removeIndex(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_replaceIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SoNode *arg4 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_replaceIndex", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_replaceIndex" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_replaceIndex" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPath_replaceIndex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoPath_replaceIndex" "', argument " "4"" of type '" "SoNode *const""'"); 
  }
  arg4 = reinterpret_cast< SoNode * >(argp4);
  (arg1)->replaceIndex(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_isRelevantNotification(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoNotList *arg2 = (SoNotList *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_isRelevantNotification", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_isRelevantNotification" "', argument " "1"" of type '" "SoPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_isRelevantNotification" "', argument " "2"" of type '" "SoNotList *const""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  result = (SbBool)((SoPath const *)arg1)->isRelevantNotification(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath_write" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPath___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath___eq__" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath___eq__" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPath___eq__" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (int)SoPath___eq__(arg1,(SoPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoPath___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPath___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPath___nq__" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPath___nq__" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPath___nq__" "', argument " "2"" of type '" "SoPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (int)SoPath___nq__(arg1,(SoPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoLightPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoLightPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoLightPath" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoLightPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoLightPath *)new SoLightPath(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLightPath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLightPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoLightPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoLightPath" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoLightPath *)new SoLightPath(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLightPath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLightPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoLightPath", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoLightPath__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SoLightPath__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoLightPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLightPath::SoLightPath(SoNode *,int const)\n"
    "    SoLightPath::SoLightPath(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoLightPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoLightPath" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_setHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_setHead", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_setHead" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightPath_setHead" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setHead(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_append" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_push" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_push" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_pop" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  (arg1)->pop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_setTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_setTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_setTail" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_setTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setTail(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_getTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_getTail" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  result = (SoNode *)((SoLightPath const *)arg1)->getTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_getHead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_getHead" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  result = (SoNode *)((SoLightPath const *)arg1)->getHead();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_getNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_getNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_getNode" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_getNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoLightPath const *)arg1)->getNode(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_getIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_getIndex" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_getIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoLightPath const *)arg1)->getIndex(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_getFullLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_getFullLength" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  result = (int)((SoLightPath const *)arg1)->getFullLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_truncate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_truncate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_truncate" "', argument " "1"" of type '" "SoLightPath *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightPath_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightPath_makeTempPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightPath *arg1 = 0 ;
  SoTempPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightPath_makeTempPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightPath_makeTempPath" "', argument " "1"" of type '" "SoLightPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTempPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightPath_makeTempPath" "', argument " "2"" of type '" "SoTempPath *""'"); 
  }
  arg2 = reinterpret_cast< SoTempPath * >(argp2);
  ((SoLightPath const *)arg1)->makeTempPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLightPath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFullPath_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFullPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFullPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_pop" "', argument " "1"" of type '" "SoFullPath *""'"); 
  }
  arg1 = reinterpret_cast< SoFullPath * >(argp1);
  (arg1)->pop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFullPath_getTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFullPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFullPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_getTail" "', argument " "1"" of type '" "SoFullPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoFullPath * >(argp1);
  result = (SoNode *)((SoFullPath const *)arg1)->getTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFullPath_getNodeFromTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFullPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFullPath_getNodeFromTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFullPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_getNodeFromTail" "', argument " "1"" of type '" "SoFullPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoFullPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFullPath_getNodeFromTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoFullPath const *)arg1)->getNodeFromTail(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFullPath_getIndexFromTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFullPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFullPath_getIndexFromTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFullPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_getIndexFromTail" "', argument " "1"" of type '" "SoFullPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoFullPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFullPath_getIndexFromTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoFullPath const *)arg1)->getIndexFromTail(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFullPath_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFullPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFullPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_getLength" "', argument " "1"" of type '" "SoFullPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoFullPath * >(argp1);
  result = (int)((SoFullPath const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFullPath_fromSoPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFullPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFullPath_fromSoPath" "', argument " "1"" of type '" "SoPath *""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  result = (SoFullPath *)SoFullPath_fromSoPath(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFullPath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFullPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFullPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTempPath_simpleAppend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTempPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTempPath_simpleAppend", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTempPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTempPath_simpleAppend" "', argument " "1"" of type '" "SoTempPath *""'"); 
  }
  arg1 = reinterpret_cast< SoTempPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTempPath_simpleAppend" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTempPath_simpleAppend" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->simpleAppend(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTempPath_replaceTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTempPath *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTempPath_replaceTail", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTempPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTempPath_replaceTail" "', argument " "1"" of type '" "SoTempPath *""'"); 
  }
  arg1 = reinterpret_cast< SoTempPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTempPath_replaceTail" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTempPath_replaceTail" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->replaceTail(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTempPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTempPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoActionMethodList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = (SoActionMethodList *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoActionMethodList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoActionMethodList" "', argument " "1"" of type '" "SoActionMethodList *const""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  result = (SoActionMethodList *)new SoActionMethodList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoActionMethodList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoActionMethodList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoActionMethodList" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoActionMethodList_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  SoType arg2 ;
  SoActionMethod arg3 = (SoActionMethod)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoActionMethodList_addMethod", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoActionMethodList_addMethod" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoActionMethodList_addMethod" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoActionMethodList_addMethod" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoActionMethodList_addMethod" "', argument " "3"" of type '" "SoActionMethod const""'"); 
    }
  }
  (arg1)->addMethod(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoActionMethodList_setUp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoActionMethodList_setUp" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  (arg1)->setUp();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoActionMethodList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  int arg2 ;
  SoActionMethod *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoActionMethodList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoActionMethodList___setitem__" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoActionMethodList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_f_p_SoAction_p_SoNode__void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoActionMethodList___setitem__" "', argument " "3"" of type '" "SoActionMethod *""'"); 
  }
  arg3 = reinterpret_cast< SoActionMethod * >(argp3);
  SoActionMethodList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoActionMethodList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoActionMethod *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoActionMethodList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoActionMethodList___getitem__" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoActionMethodList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoActionMethod *) &SoActionMethodList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p_SoAction_p_SoNode__void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoActionMethodList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoActionMethodList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoActionMethod result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoActionMethodList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoActionMethodList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoActionMethodList_get" "', argument " "1"" of type '" "SoActionMethodList *""'"); 
  }
  arg1 = reinterpret_cast< SoActionMethodList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoActionMethodList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoActionMethod)SoActionMethodList_get(arg1,arg2);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoActionMethodList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoActionMethodList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoActionMethodList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_initClass", 0, 0, 0)) SWIG_fail;
  SoAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_initClasses", 0, 0, 0)) SWIG_fail;
  SoAction::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoAction" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getTypeId" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = ((SoAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_isOfType" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_isOfType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_isOfType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoAction const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_apply" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_apply" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_apply" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_apply" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_apply" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_apply" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoAction_apply__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAction::apply(SoNode *)\n"
    "    SoAction::apply(SoPath *)\n"
    "    SoAction::apply(SoPathList const &,SbBool)\n"
    "    SoAction::apply(SoPathList const &)\n"
    "    SoAction::apply(SoAction *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoAction_invalidateState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_invalidateState" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  (arg1)->invalidateState();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_nullAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_nullAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_nullAction" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_nullAction" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoAction::nullAction(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getWhatAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAction::AppliedCode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getWhatAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoAction::AppliedCode)((SoAction const *)arg1)->getWhatAppliedTo();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getNodeAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getNodeAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoNode *)((SoAction const *)arg1)->getNodeAppliedTo();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getPathAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getPathAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoPath *)((SoAction const *)arg1)->getPathAppliedTo();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getPathListAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getPathListAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoPathList *)((SoAction const *)arg1)->getPathListAppliedTo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getOriginalPathListAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getOriginalPathListAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoPathList *)((SoAction const *)arg1)->getOriginalPathListAppliedTo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_isLastPathListAppliedTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_isLastPathListAppliedTo" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SbBool)((SoAction const *)arg1)->isLastPathListAppliedTo();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getPathCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int *arg2 = 0 ;
  int **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SoAction::PathCode result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_getPathCode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getPathCode" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_getPathCode" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_getPathCode" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoAction_getPathCode" "', argument " "3"" of type '" "int const *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_getPathCode" "', argument " "3"" of type '" "int const *&""'"); 
  }
  arg3 = reinterpret_cast< int ** >(argp3);
  result = (SoAction::PathCode)(arg1)->getPathCode(*arg2,(int const *&)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_traverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_traverse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_traverse" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_traverse" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->traverse(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_hasTerminated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_hasTerminated" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SbBool)((SoAction const *)arg1)->hasTerminated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getCurPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoPath *)(arg1)->getCurPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoState *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getState" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoState *)((SoAction const *)arg1)->getState();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoState, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getCurPathCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAction::PathCode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getCurPathCode" "', argument " "1"" of type '" "SoAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoAction::PathCode)((SoAction const *)arg1)->getCurPathCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_getCurPathTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_getCurPathTail" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoNode *)(arg1)->getCurPathTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_usePathCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int *arg2 = 0 ;
  int **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_usePathCode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_usePathCode" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_usePathCode" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_usePathCode" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoAction_usePathCode" "', argument " "3"" of type '" "int const *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAction_usePathCode" "', argument " "3"" of type '" "int const *&""'"); 
  }
  arg3 = reinterpret_cast< int ** >(argp3);
  (arg1)->usePathCode(*arg2,(int const *&)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_pushCurPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_pushCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAction_pushCurPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoAction_pushCurPath" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->pushCurPath(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_pushCurPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_pushCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAction_pushCurPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->pushCurPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_popCurPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoAction::PathCode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_popCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAction_popCurPath" "', argument " "2"" of type '" "SoAction::PathCode""'");
  } 
  arg2 = static_cast< SoAction::PathCode >(val2);
  (arg1)->popCurPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_pushCurPath__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_pushCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  (arg1)->pushCurPath();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_pushCurPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAction_pushCurPath", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoAction_pushCurPath__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAction_pushCurPath__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoAction_pushCurPath__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAction_pushCurPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAction::pushCurPath(int const,SoNode *)\n"
    "    SoAction::pushCurPath(int const)\n"
    "    SoAction::pushCurPath()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoAction_popPushCurPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_popPushCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAction_popPushCurPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoAction_popPushCurPath" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->popPushCurPath(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_popPushCurPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_popPushCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAction_popPushCurPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->popPushCurPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_popPushCurPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAction_popPushCurPath", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAction_popPushCurPath__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoAction_popPushCurPath__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAction_popPushCurPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAction::popPushCurPath(int const,SoNode *)\n"
    "    SoAction::popPushCurPath(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoAction_popCurPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_popCurPath" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  (arg1)->popCurPath();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_popCurPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAction_popCurPath", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoAction_popCurPath__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAction_popCurPath__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAction_popCurPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAction::popCurPath(SoAction::PathCode const)\n"
    "    SoAction::popCurPath()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoAction_switchToPathTraversal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_switchToPathTraversal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_switchToPathTraversal" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_switchToPathTraversal" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->switchToPathTraversal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAction_switchToNodeTraversal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAction_switchToNodeTraversal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAction_switchToNodeTraversal" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAction_switchToNodeTraversal" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->switchToNodeTraversal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoTypeList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoState *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoState" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoTypeList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoState" "', argument " "2"" of type '" "SoTypeList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoState" "', argument " "2"" of type '" "SoTypeList const &""'"); 
  }
  arg2 = reinterpret_cast< SoTypeList * >(argp2);
  result = (SoState *)new SoState(arg1,(SoTypeList const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoState, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoState" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_getAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_getAction" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoAction *)((SoState const *)arg1)->getAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_getElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoState_getElement", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_getElement" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoState_getElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoElement *)(arg1)->getElement(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_getConstElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoState_getConstElement", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_getConstElement" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoState_getConstElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoElement *)((SoState const *)arg1)->getConstElement(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_push" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  (arg1)->push();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_pop" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  (arg1)->pop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_output__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  FILE *arg2 = (FILE *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_output" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoState const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_output__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_output" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ((SoState const *)arg1)->print();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_output(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoState_output", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoState_output__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoState_output__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoState_output'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoState::print(FILE *const) const\n"
    "    SoState::print() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoState_isElementEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoState_isElementEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_isElementEnabled" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoState_isElementEnabled" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoState const *)arg1)->isElementEnabled(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_getDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_getDepth" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)((SoState const *)arg1)->getDepth();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_setCacheOpen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoState_setCacheOpen", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_setCacheOpen" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoState_setCacheOpen" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCacheOpen(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_isCacheOpen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_isCacheOpen" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)((SoState const *)arg1)->isCacheOpen();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoState_getElementNoPush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoState_getElementNoPush", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoState_getElementNoPush" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoState_getElementNoPush" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoElement *)((SoState const *)arg1)->getElementNoPush(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoState, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_initClass", 0, 0, 0)) SWIG_fail;
  SoElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_getTypeId" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  result = ((SoElement const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_getStackIndex" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  result = (int)((SoElement const *)arg1)->getStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_init" "', argument " "1"" of type '" "SoElement *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_push" "', argument " "1"" of type '" "SoElement *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_pop" "', argument " "1"" of type '" "SoElement *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_matches" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_copyMatchInfo" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  result = (SoElement *)((SoElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_initElements(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_initElements", 0, 0, 0)) SWIG_fail;
  SoElement::initElements();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getNumStackIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_getNumStackIndices", 0, 0, 0)) SWIG_fail;
  result = (int)SoElement::getNumStackIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getIdFromStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoElement_getIdFromStackIndex" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = SoElement::getIdFromStackIndex(arg1);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_setDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElement_setDepth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_setDepth" "', argument " "1"" of type '" "SoElement *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoElement_setDepth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setDepth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_getDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_getDepth" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  result = (int)((SoElement const *)arg1)->getDepth();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_output__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_output" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_output__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElement_output" "', argument " "1"" of type '" "SoElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  ((SoElement const *)arg1)->print();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElement_output(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoElement_output", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoElement_output__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoElement_output__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoElement_output'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoElement::print(FILE *) const\n"
    "    SoElement::print() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoElement" "', argument " "1"" of type '" "SoElement *""'"); 
  }
  arg1 = reinterpret_cast< SoElement * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoInt32Element_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInt32Element::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoInt32Element::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_initClass", 0, 0, 0)) SWIG_fail;
  SoInt32Element::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInt32Element *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInt32Element, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInt32Element_init" "', argument " "1"" of type '" "SoInt32Element *""'"); 
  }
  arg1 = reinterpret_cast< SoInt32Element * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInt32Element_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInt32Element *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInt32Element, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInt32Element_matches" "', argument " "1"" of type '" "SoInt32Element const *""'"); 
  }
  arg1 = reinterpret_cast< SoInt32Element * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInt32Element_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoInt32Element const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInt32Element *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInt32Element, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInt32Element_copyMatchInfo" "', argument " "1"" of type '" "SoInt32Element const *""'"); 
  }
  arg1 = reinterpret_cast< SoInt32Element * >(argp1);
  result = (SoElement *)((SoInt32Element const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInt32Element *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInt32Element, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInt32Element_output" "', argument " "1"" of type '" "SoInt32Element const *""'"); 
  }
  arg1 = reinterpret_cast< SoInt32Element * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoInt32Element const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  SoNode *arg3 = (SoNode *)0 ;
  int32_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoInt32Element_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInt32Element_set" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInt32Element_set" "', argument " "3"" of type '" "SoNode *const""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoInt32Element_set" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  SoInt32Element::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  int32_t arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoInt32Element_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInt32Element_set" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInt32Element_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoInt32Element::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInt32Element_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInt32Element_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoInt32Element_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInt32Element_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInt32Element::set(int const,SoState *const,SoNode *const,int32_t const)\n"
    "    SoInt32Element::set(int const,SoState *const,int32_t const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_get", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoInt32Element_get" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInt32Element_get" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (int32_t)SoInt32Element::get(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInt32Element_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInt32Element *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInt32Element_setElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInt32Element, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInt32Element_setElt" "', argument " "1"" of type '" "SoInt32Element *""'"); 
  }
  arg1 = reinterpret_cast< SoInt32Element * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoInt32Element_setElt" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  (arg1)->setElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInt32Element_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInt32Element, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecimationTypeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoDecimationTypeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecimationTypeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoDecimationTypeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecimationTypeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecimationTypeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationTypeElement_init" "', argument " "1"" of type '" "SoDecimationTypeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDecimationTypeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecimationTypeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoDecimationTypeElement::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationTypeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDecimationTypeElement_set" "', argument " "2"" of type '" "SoDecimationTypeElement::Type""'");
  } 
  arg2 = static_cast< SoDecimationTypeElement::Type >(val2);
  SoDecimationTypeElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoDecimationTypeElement::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationTypeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecimationTypeElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDecimationTypeElement_set" "', argument " "3"" of type '" "SoDecimationTypeElement::Type""'");
  } 
  arg3 = static_cast< SoDecimationTypeElement::Type >(val3);
  SoDecimationTypeElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoDecimationTypeElement_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoDecimationTypeElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDecimationTypeElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDecimationTypeElement::set(SoState *const,SoDecimationTypeElement::Type const)\n"
    "    SoDecimationTypeElement::set(SoState *const,SoNode *const,SoDecimationTypeElement::Type const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDecimationTypeElement::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationTypeElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoDecimationTypeElement::Type)SoDecimationTypeElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationTypeElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecimationTypeElement::Type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationTypeElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoDecimationTypeElement::Type)SoDecimationTypeElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecimationTypeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecimationTypeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoFieldData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoFieldData *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoFieldData *)new SoFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoFieldData,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoFieldData" "', argument " "1"" of type '" "SoFieldData const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoFieldData" "', argument " "1"" of type '" "SoFieldData const &""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  result = (SoFieldData *)new SoFieldData((SoFieldData const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoFieldData" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  result = (SoFieldData *)new SoFieldData((SoFieldData const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldData__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoFieldData" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoFieldData *)new SoFieldData(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoFieldData", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoFieldData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoFieldData, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoFieldData__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoFieldData__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoFieldData__SWIG_3(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoFieldData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldData::SoFieldData()\n"
    "    SoFieldData::SoFieldData(SoFieldData const &)\n"
    "    SoFieldData::SoFieldData(SoFieldData const *)\n"
    "    SoFieldData::SoFieldData(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoFieldData" "', argument " "1"" of type '" "SoFieldData *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_addField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  char *arg3 = 0 ;
  SoField *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_addField", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_addField" "', argument " "1"" of type '" "SoFieldData *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_addField" "', argument " "2"" of type '" "SoFieldContainer *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_addField" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoFieldData_addField" "', argument " "4"" of type '" "SoField const *""'"); 
  }
  arg4 = reinterpret_cast< SoField * >(argp4);
  (arg1)->addField(arg2,(char const *)arg3,(SoField const *)arg4);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_overlay", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_overlay" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_overlay" "', argument " "2"" of type '" "SoFieldContainer *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_overlay" "', argument " "3"" of type '" "SoFieldContainer const *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFieldData_overlay" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ((SoFieldData const *)arg1)->overlay(arg2,(SoFieldContainer const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_getNumFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_getNumFields" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  result = (int)((SoFieldData const *)arg1)->getNumFields();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_getFieldName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_getFieldName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_getFieldName" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldData_getFieldName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &((SoFieldData const *)arg1)->getFieldName(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_getField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_getField", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_getField" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_getField" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFieldData_getField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoField *)((SoFieldData const *)arg1)->getField((SoFieldContainer const *)arg2,arg3);
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SoField *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_getIndex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_getIndex" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_getIndex" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_getIndex" "', argument " "3"" of type '" "SoField const *""'"); 
  }
  arg3 = reinterpret_cast< SoField * >(argp3);
  result = (int)((SoFieldData const *)arg1)->getIndex((SoFieldContainer const *)arg2,(SoField const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_addEnumValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_addEnumValue", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_addEnumValue" "', argument " "1"" of type '" "SoFieldData *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_addEnumValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_addEnumValue" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFieldData_addEnumValue" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addEnumValue((char const *)arg2,(char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_getEnumData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  char *arg2 = 0 ;
  int *arg3 = 0 ;
  int **arg4 = 0 ;
  SbName **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_getEnumData", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_getEnumData" "', argument " "1"" of type '" "SoFieldData *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_getEnumData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_getEnumData" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldData_getEnumData" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoFieldData_getEnumData" "', argument " "4"" of type '" "int const *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldData_getEnumData" "', argument " "4"" of type '" "int const *&""'"); 
  }
  arg4 = reinterpret_cast< int ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_SbName,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoFieldData_getEnumData" "', argument " "5"" of type '" "SbName const *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldData_getEnumData" "', argument " "5"" of type '" "SbName const *&""'"); 
  }
  arg5 = reinterpret_cast< SbName ** >(argp5);
  (arg1)->getEnumData((char const *)arg2,*arg3,(int const *&)*arg4,(SbName const *&)*arg5);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_read__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  SbBool arg4 ;
  SbBool *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_read" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_read" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_read" "', argument " "3"" of type '" "SoFieldContainer *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFieldData_read" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoFieldData_read" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldData_read" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  arg5 = reinterpret_cast< SbBool * >(argp5);
  result = (SbBool)((SoFieldData const *)arg1)->read(arg2,arg3,arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_read__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  SbName *arg4 = 0 ;
  SbBool *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_read" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_read" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_read" "', argument " "3"" of type '" "SoFieldContainer *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoFieldData_read" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldData_read" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  arg5 = reinterpret_cast< SbBool * >(argp5);
  result = (SbBool)((SoFieldData const *)arg1)->read(arg2,arg3,(SbName const &)*arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_read(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldData_read", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoInput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoFieldData_read__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoInput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) && 
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoFieldData_read__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldData_read'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldData::read(SoInput *,SoFieldContainer *,SbBool,SbBool &) const\n"
    "    SoFieldData::read(SoInput *,SoFieldContainer *,SbName const &,SbBool &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldData_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_write", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_write" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_write" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_write" "', argument " "3"" of type '" "SoFieldContainer const *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ((SoFieldData const *)arg1)->write(arg2,(SoFieldContainer const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_copy" "', argument " "1"" of type '" "SoFieldData *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_copy" "', argument " "2"" of type '" "SoFieldData const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldData * >(argp2);
  (arg1)->copy((SoFieldData const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_isSame", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_isSame" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_isSame" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_isSame" "', argument " "3"" of type '" "SoFieldContainer const *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  result = (SbBool)((SoFieldData const *)arg1)->isSame((SoFieldContainer const *)arg2,(SoFieldContainer const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_readFieldDescriptions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  int arg4 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "3"" of type '" "SoFieldContainer *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  result = (SbBool)((SoFieldData const *)arg1)->readFieldDescriptions(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_readFieldDescriptions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "3"" of type '" "SoFieldContainer *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFieldData_readFieldDescriptions" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (SbBool)((SoFieldData const *)arg1)->readFieldDescriptions(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldData_readFieldDescriptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldData_readFieldDescriptions", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoInput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoFieldData_readFieldDescriptions__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoInput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoFieldData_readFieldDescriptions__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldData_readFieldDescriptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldData::readFieldDescriptions(SoInput *,SoFieldContainer *,int,SbBool const) const\n"
    "    SoFieldData::readFieldDescriptions(SoInput *,SoFieldContainer *,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldData_writeFieldDescriptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldData *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SoFieldContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldData_writeFieldDescriptions", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldData_writeFieldDescriptions" "', argument " "1"" of type '" "SoFieldData const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldData_writeFieldDescriptions" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldData_writeFieldDescriptions" "', argument " "3"" of type '" "SoFieldContainer const *""'"); 
  }
  arg3 = reinterpret_cast< SoFieldContainer * >(argp3);
  ((SoFieldData const *)arg1)->writeFieldDescriptions(arg2,(SoFieldContainer const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFieldData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFieldData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFieldData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFieldContainer_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_initClass", 0, 0, 0)) SWIG_fail;
  SoFieldContainer::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFieldContainer::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoFieldContainer::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_setToDefaults(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_setToDefaults" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  (arg1)->setToDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_hasDefaultValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_hasDefaultValues" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SbBool)((SoFieldContainer const *)arg1)->hasDefaultValues();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_fieldsAreEqual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_fieldsAreEqual", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_fieldsAreEqual" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_fieldsAreEqual" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  result = (SbBool)((SoFieldContainer const *)arg1)->fieldsAreEqual((SoFieldContainer const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyFieldValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_copyFieldValues" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_copyFieldValues" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFieldContainer_copyFieldValues" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyFieldValues((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyFieldValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_copyFieldValues" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_copyFieldValues" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  (arg1)->copyFieldValues((SoFieldContainer const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyFieldValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldContainer_copyFieldValues", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoFieldContainer_copyFieldValues__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoFieldContainer_copyFieldValues__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldContainer_copyFieldValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldContainer::copyFieldValues(SoFieldContainer const *,SbBool)\n"
    "    SoFieldContainer::copyFieldValues(SoFieldContainer const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_set" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_set" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->set((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_get" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->get(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getFields", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getFields" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_getFields" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldContainer_getFields" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoFieldContainer const *)arg1)->getFields(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getAllFields(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getAllFields", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getAllFields" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_getAllFields" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldContainer_getAllFields" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoFieldContainer const *)arg1)->getAllFields(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getField", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getField" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoField *)((SoFieldContainer const *)arg1)->getField((SbName const &)*arg2);
  {
    resultobj = autocast_field(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getEventIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getEventIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getEventIn" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoField *)((SoFieldContainer const *)arg1)->getEventIn((SbName const &)*arg2);
  {
    resultobj = autocast_field(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getEventOut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getEventOut", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getEventOut" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoField *)((SoFieldContainer const *)arg1)->getEventOut((SbName const &)*arg2);
  {
    resultobj = autocast_field(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFieldName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoField *arg2 = (SoField *)0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getFieldName" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_getFieldName" "', argument " "2"" of type '" "SoField const *const""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)((SoFieldContainer const *)arg1)->getFieldName((SoField const *)arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_enableNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_enableNotify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_enableNotify" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldContainer_enableNotify" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbBool)(arg1)->enableNotify(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_isNotifyEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_isNotifyEnabled" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SbBool)((SoFieldContainer const *)arg1)->isNotifyEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  char *arg2 = 0 ;
  SoInput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_set" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldContainer_set" "', argument " "3"" of type '" "SoInput *""'"); 
  }
  arg3 = reinterpret_cast< SoInput * >(argp3);
  result = (SbBool)(arg1)->set((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldContainer_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoFieldContainer_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoInput, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoFieldContainer_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldContainer_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldContainer::set(char const *const)\n"
    "    SoFieldContainer::set(char const *,SoInput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SoOutput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_get" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldContainer_get" "', argument " "3"" of type '" "SoOutput *""'"); 
  }
  arg3 = reinterpret_cast< SoOutput * >(argp3);
  (arg1)->get(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldContainer_get", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoFieldContainer_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoOutput, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoFieldContainer_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldContainer_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldContainer::get(SbString &)\n"
    "    SoFieldContainer::get(SbString &,SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_notify" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_validateNewFieldValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_validateNewFieldValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_validateNewFieldValue" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_validateNewFieldValue" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldContainer_validateNewFieldValue" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (SbBool)(arg1)->validateNewFieldValue(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_addWriteReference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_addWriteReference" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFieldContainer_addWriteReference" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->addWriteReference(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_addWriteReference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_addWriteReference" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->addWriteReference(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_addWriteReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldContainer_addWriteReference", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoFieldContainer_addWriteReference__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoFieldContainer_addWriteReference__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldContainer_addWriteReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldContainer::addWriteReference(SoOutput *,SbBool)\n"
    "    SoFieldContainer::addWriteReference(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_writeInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_writeInstance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_writeInstance" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_writeInstance" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->writeInstance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getIsBuiltIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getIsBuiltIn" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SbBool)((SoFieldContainer const *)arg1)->getIsBuiltIn();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getFieldData" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SoFieldData *)((SoFieldContainer const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_copyContents" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFieldContainer_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyThroughConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_copyThroughConnection" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SoFieldContainer *)((SoFieldContainer const *)arg1)->copyThroughConnection();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_initCopyDict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_initCopyDict", 0, 0, 0)) SWIG_fail;
  SoFieldContainer::initCopyDict();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_addCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_addCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_addCopy" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_addCopy" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  SoFieldContainer::addCopy((SoFieldContainer const *)arg1,(SoFieldContainer const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_checkCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_checkCopy" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (SoFieldContainer *)SoFieldContainer::checkCopy((SoFieldContainer const *)arg1);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_findCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_findCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_findCopy" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFieldContainer_findCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SoFieldContainer *)SoFieldContainer::findCopy((SoFieldContainer const *)arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_copyDone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_copyDone", 0, 0, 0)) SWIG_fail;
  SoFieldContainer::copyDone();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFieldsMemorySize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  size_t *arg2 = 0 ;
  size_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_getFieldsMemorySize", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getFieldsMemorySize" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_size_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_getFieldsMemorySize" "', argument " "2"" of type '" "size_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldContainer_getFieldsMemorySize" "', argument " "2"" of type '" "size_t &""'"); 
  }
  arg2 = reinterpret_cast< size_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_size_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFieldContainer_getFieldsMemorySize" "', argument " "3"" of type '" "size_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldContainer_getFieldsMemorySize" "', argument " "3"" of type '" "size_t &""'"); 
  }
  arg3 = reinterpret_cast< size_t * >(argp3);
  ((SoFieldContainer const *)arg1)->getFieldsMemorySize(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_setUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldContainer_setUserData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_setUserData" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_setUserData" "', argument " "2"" of type '" "void *""'"); 
  }
  ((SoFieldContainer const *)arg1)->setUserData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getUserData" "', argument " "1"" of type '" "SoFieldContainer const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  result = (void *)((SoFieldContainer const *)arg1)->getUserData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFieldName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFieldContainer *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldContainer_getFieldName" "', argument " "1"" of type '" "SoFieldContainer *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldContainer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldContainer_getFieldName" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (PyObject *)SoFieldContainer_getFieldName__SWIG_1(arg1,arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldContainer_getFieldName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFieldContainer_getFieldName", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoFieldContainer_getFieldName__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFieldContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          void *ptr = NULL;
          _v = 1;
          
          
          
          
          if (!PyBytes_Check(argv[2]) && 
            !PyUnicode_Check(argv[2]) && 
            (SWIG_ConvertPtr(argv[2], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
          
          {
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_SoFieldContainer_getFieldName__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFieldContainer_getFieldName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFieldContainer::getFieldName(SoField const *const,SbName &) const\n"
    "    SoFieldContainer::getFieldName(SoField *)\n");
  return 0;
}


SWIGINTERN PyObject *SoFieldContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFieldContainer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoNode_setOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_setOverride", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_setOverride" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNode_setOverride" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setOverride(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_isOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_isOverride" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SbBool)((SoNode const *)arg1)->isOverride();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getCompatibilityTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getCompatibilityTypes" "', argument " "1"" of type '" "SoType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNode_getCompatibilityTypes" "', argument " "1"" of type '" "SoType const &""'"); 
  }
  arg1 = reinterpret_cast< SoType * >(argp1);
  result = (uint32_t)SoNode::getCompatibilityTypes((SoType const &)*arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_setNodeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoNode::NodeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_setNodeType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_setNodeType" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNode_setNodeType" "', argument " "2"" of type '" "SoNode::NodeType""'");
  } 
  arg2 = static_cast< SoNode::NodeType >(val2);
  (arg1)->setNodeType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getNodeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode::NodeType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getNodeType" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoNode::NodeType)((SoNode const *)arg1)->getNodeType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoNode *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_copy" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNode_copy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SoNode *)((SoNode const *)arg1)->copy(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoNode *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_copy" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoNode *)((SoNode const *)arg1)->copy();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNode_copy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoNode_copy__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNode_copy__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNode_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNode::copy(SbBool) const\n"
    "    SoNode::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNode_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_affectsState" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SbBool)((SoNode const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_doAction" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_GLRender" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_GLRenderBelowPath" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_GLRenderInPath" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_GLRenderOffPath" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_callback" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getBoundingBox" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getMatrix" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_handleEvent" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_pick" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_rayPick" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_search" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_write" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_audioRender" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getPrimitiveCount" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_grabEventsSetup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_grabEventsSetup" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  (arg1)->grabEventsSetup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_grabEventsCleanup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_grabEventsCleanup" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  (arg1)->grabEventsCleanup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_startNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_startNotify" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  (arg1)->startNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_notify" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getNodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getNodeId" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SbUniqueId)((SoNode const *)arg1)->getNodeId();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getChildren" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoChildList *)((SoNode const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_writeInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_writeInstance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_writeInstance" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_writeInstance" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->writeInstance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_addToCopyDict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_addToCopyDict" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoNode *)((SoNode const *)arg1)->addToCopyDict();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_copyContents" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNode_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_copyThroughConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_copyThroughConnection" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoFieldContainer *)((SoNode const *)arg1)->copyThroughConnection();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNode::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getByName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoNode *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SoNode *)SoNode::getByName((SbName const &)*arg1);
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getByName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoNodeList *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoNodeList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getByName" "', argument " "2"" of type '" "SoNodeList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNode_getByName" "', argument " "2"" of type '" "SoNodeList &""'"); 
  }
  arg2 = reinterpret_cast< SoNodeList * >(argp2);
  result = (int)SoNode::getByName((SbName const &)*arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getByName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNode_getByName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) && 
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_SoNode_getByName__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) && 
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNodeList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNode_getByName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNode_getByName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNode::getByName(SbName const &)\n"
    "    SoNode::getByName(SbName const &,SoNodeList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNode_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_initClass", 0, 0, 0)) SWIG_fail;
  SoNode::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_initClasses", 0, 0, 0)) SWIG_fail;
  SoNode::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getNextNodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbUniqueId result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getNextNodeId", 0, 0, 0)) SWIG_fail;
  result = (SbUniqueId)SoNode::getNextNodeId();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getActionMethodIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getActionMethodIndex" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNode_getActionMethodIndex" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (int)SoNode::getActionMethodIndex(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getBoundingBoxS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getBoundingBoxS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getBoundingBoxS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getBoundingBoxS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::getBoundingBoxS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_GLRenderS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_GLRenderS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_GLRenderS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_GLRenderS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::GLRenderS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_callbackS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_callbackS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_callbackS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_callbackS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::callbackS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getMatrixS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getMatrixS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getMatrixS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getMatrixS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::getMatrixS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_handleEventS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_handleEventS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_handleEventS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_handleEventS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::handleEventS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_pickS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_pickS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_pickS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_pickS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::pickS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_rayPickS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_rayPickS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_rayPickS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_rayPickS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::rayPickS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_searchS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_searchS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_searchS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_searchS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::searchS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_writeS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_writeS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_writeS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_writeS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::writeS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_audioRenderS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_audioRenderS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_audioRenderS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_audioRenderS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::audioRenderS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNode_getPrimitiveCountS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNode_getPrimitiveCountS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNode_getPrimitiveCountS" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNode_getPrimitiveCountS" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoNode::getPrimitiveCountS(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoSensorManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSensorManager", 0, 0, 0)) SWIG_fail;
  result = (SoSensorManager *)new SoSensorManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSensorManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSensorManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSensorManager" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_insertDelaySensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoDelayQueueSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_insertDelaySensor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_insertDelaySensor" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_insertDelaySensor" "', argument " "2"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoDelayQueueSensor * >(argp2);
  (arg1)->insertDelaySensor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_insertTimerSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoTimerQueueSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_insertTimerSensor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_insertTimerSensor" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_insertTimerSensor" "', argument " "2"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoTimerQueueSensor * >(argp2);
  (arg1)->insertTimerSensor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_removeDelaySensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoDelayQueueSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_removeDelaySensor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_removeDelaySensor" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_removeDelaySensor" "', argument " "2"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoDelayQueueSensor * >(argp2);
  (arg1)->removeDelaySensor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_removeTimerSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoTimerQueueSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_removeTimerSensor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_removeTimerSensor" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_removeTimerSensor" "', argument " "2"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoTimerQueueSensor * >(argp2);
  (arg1)->removeTimerSensor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_setChangedCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void (*arg2)(void *) = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_setChangedCallback" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSensorManager_setChangedCallback" "', argument " "2"" of type '" "void (*)(void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSensorManager_setChangedCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setChangedCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_rescheduleTimer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoTimerSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_rescheduleTimer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_rescheduleTimer" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_rescheduleTimer" "', argument " "2"" of type '" "SoTimerSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoTimerSensor * >(argp2);
  (arg1)->rescheduleTimer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_removeRescheduledTimer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SoTimerQueueSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_removeRescheduledTimer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_removeRescheduledTimer" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensorManager_removeRescheduledTimer" "', argument " "2"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoTimerQueueSensor * >(argp2);
  (arg1)->removeRescheduledTimer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_processDelayQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_processDelayQueue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_processDelayQueue" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSensorManager_processDelayQueue" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->processDelayQueue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_processImmediateQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_processImmediateQueue" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  (arg1)->processImmediateQueue();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_processTimerQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_processTimerQueue" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  (arg1)->processTimerQueue();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_isDelaySensorPending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_isDelaySensorPending" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  result = (SbBool)(arg1)->isDelaySensorPending();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_isTimerSensorPending__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_isTimerSensorPending" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->isTimerSensorPending(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_setDelaySensorTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_setDelaySensorTimeout", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_setDelaySensorTimeout" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setDelaySensorTimeout((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_getDelaySensorTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_getDelaySensorTimeout" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  result = (SbTime *) &(arg1)->getDelaySensorTimeout();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_doSelect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  int arg2 ;
  void *arg3 = 0 ;
  void *arg4 = 0 ;
  void *arg5 = 0 ;
  timeval *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  int res4 ;
  int res5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensorManager_doSelect", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_doSelect" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSensorManager_doSelect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSensorManager_doSelect" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSensorManager_doSelect" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoSensorManager_doSelect" "', argument " "5"" of type '" "void *""'"); 
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_timeval, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoSensorManager_doSelect" "', argument " "6"" of type '" "timeval *""'"); 
  }
  arg6 = reinterpret_cast< timeval * >(argp6);
  result = (int)(arg1)->doSelect(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_setChangedCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_setChangedCallback" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSensorManager_setChangedCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_setChangedCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSensorManager_setChangedCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSensorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSensorManager_setChangedCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSensorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSensorManager_setChangedCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSensorManager_setChangedCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSensorManager::setChangedCallback(void (*)(void *),void *)\n"
    "    SoSensorManager::setChangedCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_isTimerSensorPending__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSensorManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensorManager_isTimerSensorPending" "', argument " "1"" of type '" "SoSensorManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSensorManager * >(argp1);
  result = (PyObject *)SoSensorManager_isTimerSensorPending__SWIG_1(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensorManager_isTimerSensorPending(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSensorManager_isTimerSensorPending", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSensorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSensorManager_isTimerSensorPending__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSensorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSensorManager_isTimerSensorPending__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSensorManager_isTimerSensorPending'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSensorManager::isTimerSensorPending(SbTime &)\n"
    "    SoSensorManager::isTimerSensorPending()\n");
  return 0;
}


SWIGINTERN PyObject *SoSensorManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSensorManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSensorManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDB_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_init", 0, 0, 0)) SWIG_fail;
  SoDB::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_finish(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_finish", 0, 0, 0)) SWIG_fail;
  SoDB::finish();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_cleanup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_cleanup", 0, 0, 0)) SWIG_fail;
  SoDB::cleanup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getVersion", 0, 0, 0)) SWIG_fail;
  result = (char *)SoDB::getVersion();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_read__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoPath **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoPath,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_read" "', argument " "2"" of type '" "SoPath *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_read" "', argument " "2"" of type '" "SoPath *&""'"); 
  }
  arg2 = reinterpret_cast< SoPath ** >(argp2);
  result = (SbBool)SoDB::read(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_read__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoBase **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_read" "', argument " "2"" of type '" "SoBase *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_read" "', argument " "2"" of type '" "SoBase *&""'"); 
  }
  arg2 = reinterpret_cast< SoBase ** >(argp2);
  result = (SbBool)SoDB::read(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_read__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoNode **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_SoNode,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_read" "', argument " "2"" of type '" "SoNode *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_read" "', argument " "2"" of type '" "SoNode *&""'"); 
  }
  arg2 = reinterpret_cast< SoNode ** >(argp2);
  result = (SbBool)SoDB::read(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_read(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDB_read", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_SoPath, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDB_read__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_SoNode, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDB_read__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_SoBase, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDB_read__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDB_read'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDB::read(SoInput *,SoPath *&)\n"
    "    SoDB::read(SoInput *,SoBase *&)\n"
    "    SoDB::read(SoInput *,SoNode *&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDB_readAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSeparator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_readAll" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SoSeparator *)SoDB::readAll(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_readAllVRML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVRMLGroup *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_readAllVRML" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SoVRMLGroup *)SoDB::readAllVRML(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_isValidHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_isValidHeader" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SbBool)SoDB::isValidHeader((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_registerHeader__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbBool arg2 ;
  float arg3 ;
  SoDBHeaderCB *arg4 = 0 ;
  SoDBHeaderCB *arg5 = 0 ;
  void *arg6 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int res6 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDB_registerHeader" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDB_registerHeader" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_p_SoInput__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_registerHeader" "', argument " "4"" of type '" "SoDBHeaderCB *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_SoInput__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_registerHeader" "', argument " "5"" of type '" "SoDBHeaderCB *""'"); 
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoDB_registerHeader" "', argument " "6"" of type '" "void *""'"); 
  }
  result = (SbBool)SoDB::registerHeader((SbString const &)*arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_registerHeader__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbBool arg2 ;
  float arg3 ;
  SoDBHeaderCB *arg4 = 0 ;
  SoDBHeaderCB *arg5 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDB_registerHeader" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDB_registerHeader" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_p_SoInput__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_registerHeader" "', argument " "4"" of type '" "SoDBHeaderCB *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_SoInput__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_registerHeader" "', argument " "5"" of type '" "SoDBHeaderCB *""'"); 
    }
  }
  result = (SbBool)SoDB::registerHeader((SbString const &)*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_registerHeader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDB_registerHeader", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_p_SoInput__void);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *ptr = 0;
            int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_void_p_SoInput__void);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoDB_registerHeader__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_p_SoInput__void);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *ptr = 0;
            int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_void_p_SoInput__void);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *ptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SoDB_registerHeader__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDB_registerHeader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDB::registerHeader(SbString const &,SbBool,float,SoDBHeaderCB *,SoDBHeaderCB *,void *)\n"
    "    SoDB::registerHeader(SbString const &,SbBool,float,SoDBHeaderCB *,SoDBHeaderCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDB_getHeaderData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  float *arg3 = 0 ;
  SoDBHeaderCB **arg4 = 0 ;
  SoDBHeaderCB **arg5 = 0 ;
  void **arg6 = 0 ;
  SbBool arg7 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_getHeaderData" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_getHeaderData" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_f_p_void_p_SoInput__void,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDB_getHeaderData" "', argument " "4"" of type '" "SoDBHeaderCB *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "4"" of type '" "SoDBHeaderCB *&""'"); 
  }
  arg4 = reinterpret_cast< SoDBHeaderCB ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_f_p_void_p_SoInput__void,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDB_getHeaderData" "', argument " "5"" of type '" "SoDBHeaderCB *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "5"" of type '" "SoDBHeaderCB *&""'"); 
  }
  arg5 = reinterpret_cast< SoDBHeaderCB ** >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoDB_getHeaderData" "', argument " "6"" of type '" "void *&""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "6"" of type '" "void *&""'"); 
  }
  arg6 = reinterpret_cast< void ** >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoDB_getHeaderData" "', argument " "7"" of type '" "SbBool""'");
  } 
  arg7 = static_cast< SbBool >(val7);
  result = (SbBool)SoDB::getHeaderData((SbString const &)*arg1,*arg2,*arg3,*arg4,*arg5,*arg6,arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getHeaderData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  float *arg3 = 0 ;
  SoDBHeaderCB **arg4 = 0 ;
  SoDBHeaderCB **arg5 = 0 ;
  void **arg6 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_getHeaderData" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_getHeaderData" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_f_p_void_p_SoInput__void,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDB_getHeaderData" "', argument " "4"" of type '" "SoDBHeaderCB *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "4"" of type '" "SoDBHeaderCB *&""'"); 
  }
  arg4 = reinterpret_cast< SoDBHeaderCB ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_f_p_void_p_SoInput__void,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDB_getHeaderData" "', argument " "5"" of type '" "SoDBHeaderCB *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "5"" of type '" "SoDBHeaderCB *&""'"); 
  }
  arg5 = reinterpret_cast< SoDBHeaderCB ** >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoDB_getHeaderData" "', argument " "6"" of type '" "void *&""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getHeaderData" "', argument " "6"" of type '" "void *&""'"); 
  }
  arg6 = reinterpret_cast< void ** >(argp6);
  result = (SbBool)SoDB::getHeaderData((SbString const &)*arg1,*arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getHeaderData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDB_getHeaderData", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_p_f_p_void_p_SoInput__void, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_f_p_void_p_SoInput__void, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_p_void, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SoDB_getHeaderData__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_p_f_p_void_p_SoInput__void, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_f_p_void_p_SoInput__void, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_p_void, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoDB_getHeaderData__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDB_getHeaderData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDB::getHeaderData(SbString const &,SbBool &,float &,SoDBHeaderCB *&,SoDBHeaderCB *&,void *&,SbBool)\n"
    "    SoDB::getHeaderData(SbString const &,SbBool &,float &,SoDBHeaderCB *&,SoDBHeaderCB *&,void *&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDB_getNumHeaders(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getNumHeaders", 0, 0, 0)) SWIG_fail;
  result = (int)SoDB::getNumHeaders();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getHeaderString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoDB_getHeaderString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = SoDB::getHeaderString(arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_createGlobalField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoType arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_createGlobalField", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_createGlobalField" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_createGlobalField" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SoField *)SoDB::createGlobalField((SbName const &)*arg1,SWIG_STD_MOVE(arg2));
  {
    resultobj = autocast_field(result);
  }
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getGlobalField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SoField *)SoDB::getGlobalField((SbName const &)*arg1);
  {
    resultobj = autocast_field(result);
  }
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_renameGlobalField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_renameGlobalField", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  SoDB::renameGlobalField((SbName const &)*arg1,(SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg1) {
      delete arg1; 
    }
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_setRealTimeInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyFloat_Check(swig_obj[0])) {
      arg1 = new SbTime(PyFloat_AsDouble(swig_obj[0]));
    } else {
      SbTime * tmp = NULL;
      arg1 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg1 = *tmp;
    }
  }
  SoDB::setRealTimeInterval((SbTime const &)*arg1);
  resultobj = SWIG_Py_Void();
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getRealTimeInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getRealTimeInterval", 0, 0, 0)) SWIG_fail;
  result = (SbTime *) &SoDB::getRealTimeInterval();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_enableRealTimeSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoDB_enableRealTimeSensor" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoDB::enableRealTimeSensor(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getSensorManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getSensorManager", 0, 0, 0)) SWIG_fail;
  result = (SoSensorManager *)SoDB::getSensorManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSensorManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_setDelaySensorTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyFloat_Check(swig_obj[0])) {
      arg1 = new SbTime(PyFloat_AsDouble(swig_obj[0]));
    } else {
      SbTime * tmp = NULL;
      arg1 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg1 = *tmp;
    }
  }
  SoDB::setDelaySensorTimeout((SbTime const &)*arg1);
  resultobj = SWIG_Py_Void();
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getDelaySensorTimeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getDelaySensorTimeout", 0, 0, 0)) SWIG_fail;
  result = (SbTime *) &SoDB::getDelaySensorTimeout();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_doSelect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  void *arg2 = 0 ;
  void *arg3 = 0 ;
  void *arg4 = 0 ;
  timeval *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  int res3 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_doSelect", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoDB_doSelect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_doSelect" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_doSelect" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDB_doSelect" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_timeval, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDB_doSelect" "', argument " "5"" of type '" "timeval *""'"); 
  }
  arg5 = reinterpret_cast< timeval * >(argp5);
  result = (int)SoDB::doSelect(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_addConverter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoType arg2 ;
  SoType arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_addConverter", 3, 3, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_addConverter" "', argument " "1"" of type '" "SoType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_addConverter" "', argument " "1"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_addConverter" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_addConverter" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_addConverter" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_addConverter" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  SoDB::addConverter(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_getConverter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoType arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_getConverter", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_getConverter" "', argument " "1"" of type '" "SoType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getConverter" "', argument " "1"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_getConverter" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDB_getConverter" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = SoDB::getConverter(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_isInitialized(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_isInitialized", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoDB::isInitialized();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_startNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_startNotify", 0, 0, 0)) SWIG_fail;
  SoDB::startNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_isNotifying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_isNotifying", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoDB::isNotifying();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_endNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_endNotify", 0, 0, 0)) SWIG_fail;
  SoDB::endNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_addProgressCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDB::ProgressCallbackType *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_addProgressCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbName_float_int_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_addProgressCallback" "', argument " "1"" of type '" "SoDB::ProgressCallbackType *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_addProgressCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoDB::addProgressCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_removeProgressCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDB::ProgressCallbackType *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_removeProgressCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbName_float_int_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDB_removeProgressCallback" "', argument " "1"" of type '" "SoDB::ProgressCallbackType *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_removeProgressCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoDB::removeProgressCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_isMultiThread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_isMultiThread", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoDB::isMultiThread();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_readlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_readlock", 0, 0, 0)) SWIG_fail;
  SoDB::readlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_readunlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_readunlock", 0, 0, 0)) SWIG_fail;
  SoDB::readunlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_writelock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_writelock", 0, 0, 0)) SWIG_fail;
  SoDB::writelock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_writeunlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_writeunlock", 0, 0, 0)) SWIG_fail;
  SoDB::writeunlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_createRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  char *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_createRoute", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_createRoute" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_createRoute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_createRoute" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDB_createRoute" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  SoDB::createRoute(arg1,(char const *)arg2,arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDB_removeRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  char *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDB_removeRoute", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDB_removeRoute" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDB_removeRoute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDB_removeRoute" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDB_removeRoute" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  SoDB::removeRoute(arg1,(char const *)arg2,arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDB", 0, 0, 0)) SWIG_fail;
  result = (SoDB *)new SoDB();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoDB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDB *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDB" "', argument " "1"" of type '" "SoDB *""'"); 
  }
  arg1 = reinterpret_cast< SoDB * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoInput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoInput *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoInput *)new SoInput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoInput *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoInput" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SoInput *)new SoInput(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoInput", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoInput__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoInput__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoInput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::SoInput()\n"
    "    SoInput::SoInput(SoInput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_findProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoProto *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_findProto", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_findProto" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoProto *)(arg1)->findProto((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoProto *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_addProto", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addProto" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_addProto" "', argument " "2"" of type '" "SoProto *""'"); 
  }
  arg2 = reinterpret_cast< SoProto * >(argp2);
  (arg1)->addProto(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_pushProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoProto *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_pushProto", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_pushProto" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_pushProto" "', argument " "2"" of type '" "SoProto *""'"); 
  }
  arg2 = reinterpret_cast< SoProto * >(argp2);
  (arg1)->pushProto(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getCurrentProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProto *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getCurrentProto" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SoProto *)((SoInput const *)arg1)->getCurrentProto();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_popProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_popProto" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  (arg1)->popProto();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbName *arg4 = 0 ;
  SbName *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_addRoute", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addRoute" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[4]))
    {
      arg5 = new SbName(PyBytes_AsString(swig_obj[4]));
    }
    else if  (PyUnicode_Check(swig_obj[4])){
      arg5 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[4], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg5 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[4], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg5 = *tmp;
    }
  }
  (arg1)->addRoute((SbName const &)*arg2,(SbName const &)*arg3,(SbName const &)*arg4,(SbName const &)*arg5);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_checkISReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbBool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_checkISReference", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_checkISReference" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_checkISReference" "', argument " "2"" of type '" "SoFieldContainer *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoInput_checkISReference" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_checkISReference" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  arg4 = reinterpret_cast< SbBool * >(argp4);
  result = (SbBool)(arg1)->checkISReference(arg2,(SbName const &)*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoInput" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_setFilePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_setFilePointer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_setFilePointer" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  (arg1)->setFilePointer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_openFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_openFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_openFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_openFile" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->openFile((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_openFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_openFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_openFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->openFile((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_openFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_openFile", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_openFile__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_openFile__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_openFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::openFile(char const *,SbBool)\n"
    "    SoInput::openFile(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_pushFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_pushFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_pushFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_pushFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->pushFile((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_closeFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_closeFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  (arg1)->closeFile();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_isValidFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_isValidFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)(arg1)->isValidFile();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_isValidBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_isValidBuffer" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)(arg1)->isValidBuffer();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getCurFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getCurFile" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (FILE *)((SoInput const *)arg1)->getCurFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getCurFileName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getCurFileName" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (char *)((SoInput const *)arg1)->getCurFileName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_setBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_setBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_setBuffer" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyUnicode_Check(swig_obj[1]))
    {
      arg2 = (void *) PyUnicode_AsUTF8(swig_obj[1]);
      arg3 = PyUnicode_GET_LENGTH(swig_obj[1]);
    }
    else if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = (void *) PyBytes_AsString(swig_obj[1]);
      arg3 = PyBytes_Size(swig_obj[1]);
    }
    
    else
    {
      PyErr_SetString(PyExc_ValueError, "Expecting a string");
      return NULL;
    }
  }
  (arg1)->setBuffer((void const *)arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_setStringArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char **arg2 = (char **)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_setStringArray", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_setStringArray" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_setStringArray" "', argument " "2"" of type '" "char const *[]""'"); 
  } 
  arg2 = reinterpret_cast< char ** >(argp2);
  (arg1)->setStringArray((char const *(*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getNumBytesRead(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getNumBytesRead" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = ((SoInput const *)arg1)->getNumBytesRead();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getHeader" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (arg1)->getHeader();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getIVVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getIVVersion" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (float)(arg1)->getIVVersion();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_isBinary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_isBinary" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)(arg1)->isBinary();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_get" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_get" "', argument " "2"" of type '" "char &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_get" "', argument " "2"" of type '" "char &""'"); 
  }
  arg2 = reinterpret_cast< char * >(argp2);
  result = (SbBool)(arg1)->get(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getASCIIBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_getASCIIBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getASCIIBuffer" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_getASCIIBuffer" "', argument " "2"" of type '" "char &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_getASCIIBuffer" "', argument " "2"" of type '" "char &""'"); 
  }
  arg2 = reinterpret_cast< char * >(argp2);
  result = (SbBool)(arg1)->getASCIIBuffer(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getASCIIFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_getASCIIFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getASCIIFile" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_getASCIIFile" "', argument " "2"" of type '" "char &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_getASCIIFile" "', argument " "2"" of type '" "char &""'"); 
  }
  arg2 = reinterpret_cast< char * >(argp2);
  result = (SbBool)(arg1)->getASCIIFile(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readHex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  uint32_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_readHex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readHex" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readHex" "', argument " "2"" of type '" "uint32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_readHex" "', argument " "2"" of type '" "uint32_t &""'"); 
  }
  arg2 = reinterpret_cast< uint32_t * >(argp2);
  result = (SbBool)(arg1)->readHex(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "char &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "char &""'"); 
  }
  arg2 = reinterpret_cast< char * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "char &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "char &""'"); 
  }
  arg2 = reinterpret_cast< char * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_read" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->read(*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_read" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->read(*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "unsigned int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "unsigned int &""'"); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  short *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  unsigned short *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_read" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_read" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_read" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  result = (SbBool)(arg1)->read(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_read(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_read", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_read__SWIG_10(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoInput_read__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoInput_read__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_read__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_read__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_read'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::read(char &)\n"
    "    SoInput::read(char &,SbBool)\n"
    "    SoInput::read(SbString &)\n"
    "    SoInput::read(SbName &,SbBool)\n"
    "    SoInput::read(SbName &)\n"
    "    SoInput::read(int &)\n"
    "    SoInput::read(unsigned int &)\n"
    "    SoInput::read(short &)\n"
    "    SoInput::read(unsigned short &)\n"
    "    SoInput::read(float &)\n"
    "    SoInput::read(double &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_readByte__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  int8_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readByte" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readByte" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_readByte" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  arg2 = reinterpret_cast< int8_t * >(argp2);
  result = (SbBool)(arg1)->readByte(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readByte__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  uint8_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readByte" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readByte" "', argument " "2"" of type '" "uint8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_readByte" "', argument " "2"" of type '" "uint8_t &""'"); 
  }
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  result = (SbBool)(arg1)->readByte(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readByte(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_readByte", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_readByte__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_readByte__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_readByte'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::readByte(int8_t &)\n"
    "    SoInput::readByte(uint8_t &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_readBinaryArray__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readBinaryArray" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readBinaryArray" "', argument " "2"" of type '" "unsigned char *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_readBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbBool)(arg1)->readBinaryArray(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readBinaryArray__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readBinaryArray" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readBinaryArray" "', argument " "2"" of type '" "int32_t *""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_readBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbBool)(arg1)->readBinaryArray(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readBinaryArray__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  float *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readBinaryArray" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readBinaryArray" "', argument " "2"" of type '" "float *""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_readBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbBool)(arg1)->readBinaryArray(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readBinaryArray__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  double *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_readBinaryArray" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_readBinaryArray" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoInput_readBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbBool)(arg1)->readBinaryArray(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_readBinaryArray(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_readBinaryArray", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_readBinaryArray__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_readBinaryArray__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_readBinaryArray__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoInput_readBinaryArray__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_readBinaryArray'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::readBinaryArray(unsigned char *,int)\n"
    "    SoInput::readBinaryArray(int32_t *,int)\n"
    "    SoInput::readBinaryArray(float *,int)\n"
    "    SoInput::readBinaryArray(double *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_eof(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_eof" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)((SoInput const *)arg1)->eof();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_isFileVRML1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_isFileVRML1" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)(arg1)->isFileVRML1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_isFileVRML2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_isFileVRML2" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  result = (SbBool)(arg1)->isFileVRML2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_resetFilePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_resetFilePointer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_resetFilePointer" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  (arg1)->resetFilePointer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getLocationString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_getLocationString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getLocationString" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((SoInput const *)arg1)->getLocationString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_putBack__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_putBack" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoInput_putBack" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->putBack(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_putBack__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_putBack" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_putBack" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->putBack((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_putBack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_putBack", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoInput_putBack__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_putBack__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_putBack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::putBack(char const)\n"
    "    SoInput::putBack(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_addReference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoBase *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addReference" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInput_addReference" "', argument " "3"" of type '" "SoBase *""'"); 
  }
  arg3 = reinterpret_cast< SoBase * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoInput_addReference" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  (arg1)->addReference((SbName const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addReference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoBase *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addReference" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInput_addReference" "', argument " "3"" of type '" "SoBase *""'"); 
  }
  arg3 = reinterpret_cast< SoBase * >(argp3);
  (arg1)->addReference((SbName const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_addReference", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoInput_addReference__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoInput_addReference__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_addReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::addReference(SbName const &,SoBase *,SbBool)\n"
    "    SoInput::addReference(SbName const &,SoBase *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_removeReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_removeReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_removeReference" "', argument " "1"" of type '" "SoInput *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->removeReference((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_findReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_findReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_findReference" "', argument " "1"" of type '" "SoInput const *""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoBase *)((SoInput const *)arg1)->findReference((SbName const &)*arg2);
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addDirectoryFirst(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addDirectoryFirst" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoInput::addDirectoryFirst((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addDirectoryLast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addDirectoryLast" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoInput::addDirectoryLast((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesFirst__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addEnvDirectoriesFirst" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_addEnvDirectoriesFirst" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoInput::addEnvDirectoriesFirst((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesFirst__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addEnvDirectoriesFirst" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoInput::addEnvDirectoriesFirst((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesFirst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_addEnvDirectoriesFirst", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoInput_addEnvDirectoriesFirst__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_addEnvDirectoriesFirst__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_addEnvDirectoriesFirst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::addEnvDirectoriesFirst(char const *,char const *)\n"
    "    SoInput::addEnvDirectoriesFirst(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesLast__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addEnvDirectoriesLast" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_addEnvDirectoriesLast" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoInput::addEnvDirectoriesLast((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesLast__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_addEnvDirectoriesLast" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoInput::addEnvDirectoriesLast((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_addEnvDirectoriesLast(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_addEnvDirectoriesLast", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoInput_addEnvDirectoriesLast__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInput_addEnvDirectoriesLast__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_addEnvDirectoriesLast'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::addEnvDirectoriesLast(char const *,char const *)\n"
    "    SoInput::addEnvDirectoriesLast(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_removeDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_removeDirectory" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoInput::removeDirectory((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_clearDirectories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_clearDirectories", 0, 0, 0)) SWIG_fail;
  SoInput::clearDirectories();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getDirectories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_getDirectories", 0, 0, 0)) SWIG_fail;
  result = (SbStringList *) &SoInput::getDirectories();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStringList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_init", 0, 0, 0)) SWIG_fail;
  SoInput::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getPathname__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getPathname" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = SoInput::getPathname((char const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getPathname__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  result = SoInput::getPathname((SbString const &)*arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getPathname(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_getPathname", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoInput_getPathname__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_SoInput_getPathname__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_getPathname'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::getPathname(char const *const)\n"
    "    SoInput::getPathname(SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_getBasename__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInput_getBasename" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = SoInput::getBasename((char const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getBasename__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  result = SoInput::getBasename((SbString const &)*arg1);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInput_getBasename(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInput_getBasename", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoInput_getBasename__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) &&
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_SoInput_getBasename__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInput_getBasename'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInput::getBasename(char const *const)\n"
    "    SoInput::getBasename(SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInput_searchForFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbStringList *arg2 = 0 ;
  SbStringList *arg3 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInput_searchForFile", 3, 3, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbStringList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInput_searchForFile" "', argument " "2"" of type '" "SbStringList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_searchForFile" "', argument " "2"" of type '" "SbStringList const &""'"); 
  }
  arg2 = reinterpret_cast< SbStringList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbStringList,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInput_searchForFile" "', argument " "3"" of type '" "SbStringList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInput_searchForFile" "', argument " "3"" of type '" "SbStringList const &""'"); 
  }
  arg3 = reinterpret_cast< SbStringList * >(argp3);
  result = SoInput::searchForFile((SbString const &)*arg1,(SbStringList const &)*arg2,(SbStringList const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoInput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoOutput *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoOutput *)new SoOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOutput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoOutput *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoOutput" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SoOutput *)new SoOutput(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOutput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOutput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoOutput", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoOutput__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoOutput__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoOutput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::SoOutput()\n"
    "    SoOutput::SoOutput(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoOutput" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setFilePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setFilePointer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setFilePointer" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  (arg1)->setFilePointer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getFilePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getFilePointer" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (FILE *)((SoOutput const *)arg1)->getFilePointer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_openFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_openFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_openFile" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_openFile" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->openFile((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_closeFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_closeFile" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->closeFile();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setCompression__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setCompression" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_setCompression" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)(arg1)->setCompression((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setCompression__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setCompression" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->setCompression((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setCompression(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_setCompression", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoOutput_setCompression__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoOutput_setCompression__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_setCompression'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::setCompression(SbName const &,float const)\n"
    "    SoOutput::setCompression(SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_getAvailableCompressionMethods(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getAvailableCompressionMethods" "', argument " "1"" of type '" "unsigned int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOutput_getAvailableCompressionMethods" "', argument " "1"" of type '" "unsigned int &""'"); 
  }
  arg1 = reinterpret_cast< unsigned int * >(argp1);
  result = (SbName *)SoOutput::getAvailableCompressionMethods(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setBuffer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  SoOutputReallocCB *arg4 = 0 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setBuffer" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_setBuffer" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_setBuffer" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_size_t__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoOutput_setBuffer" "', argument " "4"" of type '" "SoOutputReallocCB *""'"); 
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoOutput_setBuffer" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  (arg1)->setBuffer(arg2,SWIG_STD_MOVE(arg3),arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setBuffer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  SoOutputReallocCB *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setBuffer" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_setBuffer" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_setBuffer" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_size_t__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoOutput_setBuffer" "', argument " "4"" of type '" "SoOutputReallocCB *""'"); 
    }
  }
  (arg1)->setBuffer(arg2,SWIG_STD_MOVE(arg3),arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_setBuffer", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_size_t__p_void);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoOutput_setBuffer__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_size_t__p_void);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoOutput_setBuffer__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_setBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::setBuffer(void *,size_t,SoOutputReallocCB *,int32_t)\n"
    "    SoOutput::setBuffer(void *,size_t,SoOutputReallocCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_getBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void **arg2 = 0 ;
  size_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_getBuffer", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getBuffer" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_getBuffer" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOutput_getBuffer" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_size_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoOutput_getBuffer" "', argument " "3"" of type '" "size_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOutput_getBuffer" "', argument " "3"" of type '" "size_t &""'"); 
  }
  arg3 = reinterpret_cast< size_t * >(argp3);
  result = (SbBool)((SoOutput const *)arg1)->getBuffer(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getBufferSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getBufferSize" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = ((SoOutput const *)arg1)->getBufferSize();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_resetBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_resetBuffer" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->resetBuffer();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setBinary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setBinary", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setBinary" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_setBinary" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setBinary(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_isBinary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_isBinary" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SbBool)((SoOutput const *)arg1)->isBinary();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setHeaderString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setHeaderString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setHeaderString" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setHeaderString((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_resetHeaderString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_resetHeaderString" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->resetHeaderString();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setFloatPrecision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setFloatPrecision", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setFloatPrecision" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_setFloatPrecision" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFloatPrecision(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoOutput::Stage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setStage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setStage" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_setStage" "', argument " "2"" of type '" "SoOutput::Stage""'");
  } 
  arg2 = static_cast< SoOutput::Stage >(val2);
  (arg1)->setStage(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getStage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoOutput::Stage result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getStage" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SoOutput::Stage)((SoOutput const *)arg1)->getStage();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_incrementIndent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_incrementIndent" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_incrementIndent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->incrementIndent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_incrementIndent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_incrementIndent" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->incrementIndent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_incrementIndent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_incrementIndent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoOutput_incrementIndent__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_incrementIndent__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_incrementIndent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::incrementIndent(int const)\n"
    "    SoOutput::incrementIndent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_decrementIndent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_decrementIndent" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_decrementIndent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->decrementIndent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_decrementIndent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_decrementIndent" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->decrementIndent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_decrementIndent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_decrementIndent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoOutput_decrementIndent__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_decrementIndent__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_decrementIndent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::decrementIndent(int const)\n"
    "    SoOutput::decrementIndent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->write((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->write((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->write((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_write" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_write" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_write(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_write", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOutput_write__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoOutput_write__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_write'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::write(char const)\n"
    "    SoOutput::write(char const *)\n"
    "    SoOutput::write(SbString const &)\n"
    "    SoOutput::write(SbName const &)\n"
    "    SoOutput::write(int const)\n"
    "    SoOutput::write(unsigned int const)\n"
    "    SoOutput::write(short const)\n"
    "    SoOutput::write(unsigned short const)\n"
    "    SoOutput::write(float const)\n"
    "    SoOutput::write(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_writeBinaryArray__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_writeBinaryArray" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_writeBinaryArray" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_writeBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->writeBinaryArray((unsigned char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_writeBinaryArray__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_writeBinaryArray" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_writeBinaryArray" "', argument " "2"" of type '" "int32_t const *const""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_writeBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->writeBinaryArray((int32_t const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_writeBinaryArray__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_writeBinaryArray" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_writeBinaryArray" "', argument " "2"" of type '" "float const *const""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_writeBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->writeBinaryArray((float const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_writeBinaryArray__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_writeBinaryArray" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_writeBinaryArray" "', argument " "2"" of type '" "double const *const""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_writeBinaryArray" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->writeBinaryArray((double const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_writeBinaryArray(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOutput_writeBinaryArray", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoOutput_writeBinaryArray__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoOutput_writeBinaryArray__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoOutput_writeBinaryArray__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoOutput_writeBinaryArray__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOutput_writeBinaryArray'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOutput::writeBinaryArray(unsigned char const *,int const)\n"
    "    SoOutput::writeBinaryArray(int32_t const *const,int const)\n"
    "    SoOutput::writeBinaryArray(float const *const,int const)\n"
    "    SoOutput::writeBinaryArray(double const *const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOutput_indent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_indent" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->indent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_reset" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setCompact(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setCompact", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setCompact" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_setCompact" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCompact(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_isCompact(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_isCompact" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SbBool)((SoOutput const *)arg1)->isCompact();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setAnnotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setAnnotation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setAnnotation" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOutput_setAnnotation" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setAnnotation(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getAnnotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getAnnotation" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (uint32_t)(arg1)->getAnnotation();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getDefaultASCIIHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_getDefaultASCIIHeader", 0, 0, 0)) SWIG_fail;
  result = SoOutput::getDefaultASCIIHeader();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getDefaultBinaryHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_getDefaultBinaryHeader", 0, 0, 0)) SWIG_fail;
  result = SoOutput::getDefaultBinaryHeader();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_addReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_addReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_addReference" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_addReference" "', argument " "2"" of type '" "SoBase const *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  result = (int)(arg1)->addReference((SoBase const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_findReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_findReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_findReference" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_findReference" "', argument " "2"" of type '" "SoBase const *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  result = (int)((SoOutput const *)arg1)->findReference((SoBase const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_setReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_setReference", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_setReference" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_setReference" "', argument " "2"" of type '" "SoBase const *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOutput_setReference" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setReference((SoBase const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_addDEFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_addDEFNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_addDEFNode" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  (arg1)->addDEFNode(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_lookupDEFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_lookupDEFNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_lookupDEFNode" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  result = (SbBool)(arg1)->lookupDEFNode(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_removeDEFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_removeDEFNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_removeDEFNode" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  (arg1)->removeDEFNode(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_pushProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoProto *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_pushProto", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_pushProto" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_pushProto" "', argument " "2"" of type '" "SoProto *""'"); 
  }
  arg2 = reinterpret_cast< SoProto * >(argp2);
  (arg1)->pushProto(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_getCurrentProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProto *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_getCurrentProto" "', argument " "1"" of type '" "SoOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SoProto *)((SoOutput const *)arg1)->getCurrentProto();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_popProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_popProto" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->popProto();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_addRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SoFieldContainer *arg4 = 0 ;
  SbName *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOutput_addRoute", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_addRoute" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOutput_addRoute" "', argument " "2"" of type '" "SoFieldContainer *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoOutput_addRoute" "', argument " "4"" of type '" "SoFieldContainer *""'"); 
  }
  arg4 = reinterpret_cast< SoFieldContainer * >(argp4);
  {
    if (PyBytes_Check(swig_obj[4]))
    {
      arg5 = new SbName(PyBytes_AsString(swig_obj[4]));
    }
    else if  (PyUnicode_Check(swig_obj[4])){
      arg5 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[4], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg5 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[4], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg5 = *tmp;
    }
  }
  (arg1)->addRoute(arg2,(SbName const &)*arg3,arg4,(SbName const &)*arg5);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOutput_resolveRoutes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOutput_resolveRoutes" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  (arg1)->resolveRoutes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFEnum", 0, 0, 0)) SWIG_fail;
  result = (SoSFEnum *)new SoSFEnum();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFEnum" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFEnum::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFEnum::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_getTypeId" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  result = ((SoSFEnum const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_copyFrom" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEnum_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEnum_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_isSame" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEnum_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEnum_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFEnum const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_getValue" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  result = (int)((SoSFEnum const *)arg1)->getValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_setValue" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFEnum_setValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum___eq__" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFEnum,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEnum___eq__" "', argument " "2"" of type '" "SoSFEnum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEnum___eq__" "', argument " "2"" of type '" "SoSFEnum const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  result = (int)((SoSFEnum const *)arg1)->operator ==((SoSFEnum const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFEnum___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum___ne__" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFEnum,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEnum___ne__" "', argument " "2"" of type '" "SoSFEnum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEnum___ne__" "', argument " "2"" of type '" "SoSFEnum const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  result = (int)((SoSFEnum const *)arg1)->operator !=((SoSFEnum const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_initClass", 0, 0, 0)) SWIG_fail;
  SoSFEnum::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_setValue" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_setEnums(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  SbName *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_setEnums", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_setEnums" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFEnum_setEnums" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFEnum_setEnums" "', argument " "3"" of type '" "int const *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFEnum_setEnums" "', argument " "4"" of type '" "SbName const *""'"); 
  }
  arg4 = reinterpret_cast< SbName * >(argp4);
  (arg1)->setEnums(arg2,(int const *)arg3,(SbName const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_getNumEnums(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_getNumEnums" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  result = (int)((SoSFEnum const *)arg1)->getNumEnums();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_getEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  int arg2 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEnum_getEnum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_getEnum" "', argument " "1"" of type '" "SoSFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFEnum_getEnum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (int)((SoSFEnum const *)arg1)->getEnum(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFEnum *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEnum_setValue" "', argument " "1"" of type '" "SoSFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEnum_setValue" "', argument " "2"" of type '" "SoSFEnum const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  SoSFEnum_setValue__SWIG_2(arg1,(SoSFEnum const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEnum_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFEnum_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFEnum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFEnum_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFEnum_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        
        // http://stackoverflow.com/questions/2807887/cs-char-by-swig-got-problem-in-python-3-0
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSFEnum_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFEnum_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFEnum::setValue(int)\n"
    "    SoSFEnum::setValue(SbName const)\n"
    "    SoSFEnum::setValue(SoSFEnum const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFEnum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFEnum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFEnum_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFFloat", 0, 0, 0)) SWIG_fail;
  result = (SoSFFloat *)new SoSFFloat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFFloat" "', argument " "1"" of type '" "SoSFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFFloat::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFFloat::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_getTypeId" "', argument " "1"" of type '" "SoSFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  result = ((SoSFFloat const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_copyFrom" "', argument " "1"" of type '" "SoSFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFFloat_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFFloat_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_isSame" "', argument " "1"" of type '" "SoSFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFFloat_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFFloat_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFFloat const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_getValue" "', argument " "1"" of type '" "SoSFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  result = (float)((SoSFFloat const *)arg1)->getValue();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_setValue" "', argument " "1"" of type '" "SoSFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFFloat_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat___eq__" "', argument " "1"" of type '" "SoSFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFFloat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFFloat___eq__" "', argument " "2"" of type '" "SoSFFloat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFFloat___eq__" "', argument " "2"" of type '" "SoSFFloat const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  result = (int)((SoSFFloat const *)arg1)->operator ==((SoSFFloat const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFFloat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat___ne__" "', argument " "1"" of type '" "SoSFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFFloat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFFloat___ne__" "', argument " "2"" of type '" "SoSFFloat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFFloat___ne__" "', argument " "2"" of type '" "SoSFFloat const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  result = (int)((SoSFFloat const *)arg1)->operator !=((SoSFFloat const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFFloat_initClass", 0, 0, 0)) SWIG_fail;
  SoSFFloat::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFFloat *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFFloat_setValue" "', argument " "1"" of type '" "SoSFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoSFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFFloat_setValue" "', argument " "2"" of type '" "SoSFFloat const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  SoSFFloat_setValue__SWIG_1(arg1,(SoSFFloat const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFFloat_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFFloat_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFFloat, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFFloat_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFFloat_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFFloat_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFFloat::setValue(float)\n"
    "    SoSFFloat::setValue(SoSFFloat const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFFloat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFFloat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFFloat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComplexityTypeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoComplexityTypeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComplexityTypeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoComplexityTypeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexityTypeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexityTypeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityTypeElement_init" "', argument " "1"" of type '" "SoComplexityTypeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexityTypeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexityTypeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoComplexityTypeElement::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityTypeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexityTypeElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoComplexityTypeElement_set" "', argument " "3"" of type '" "SoComplexityTypeElement::Type""'");
  } 
  arg3 = static_cast< SoComplexityTypeElement::Type >(val3);
  SoComplexityTypeElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoComplexityTypeElement::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityTypeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoComplexityTypeElement_set" "', argument " "2"" of type '" "SoComplexityTypeElement::Type""'");
  } 
  arg2 = static_cast< SoComplexityTypeElement::Type >(val2);
  SoComplexityTypeElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoComplexityTypeElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoComplexityTypeElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoComplexityTypeElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoComplexityTypeElement::set(SoState *const,SoNode *const,SoComplexityTypeElement::Type const)\n"
    "    SoComplexityTypeElement::set(SoState *const,SoComplexityTypeElement::Type const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoComplexityTypeElement::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityTypeElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoComplexityTypeElement::Type)SoComplexityTypeElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityTypeElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexityTypeElement::Type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityTypeElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoComplexityTypeElement::Type)SoComplexityTypeElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComplexityTypeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComplexityTypeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoComplexity_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComplexity::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_getTypeId" "', argument " "1"" of type '" "SoComplexity const *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  result = ((SoComplexity const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_initClass", 0, 0, 0)) SWIG_fail;
  SoComplexity::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComplexity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComplexity", 0, 0, 0)) SWIG_fail;
  result = (SoComplexity *)new SoComplexity();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComplexity, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_type_set" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_type_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_type_get" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  result = (SoSFEnum *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_value_set" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_value_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_value_get" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  result = (SoSFFloat *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_textureQuality_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_textureQuality_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_textureQuality_set" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_textureQuality_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->textureQuality = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_textureQuality_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_textureQuality_get" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  result = (SoSFFloat *)& ((arg1)->textureQuality);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_doAction" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_callback" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_getBoundingBox" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_GLRender" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_pick" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexity_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexity *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexity_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexity_getPrimitiveCount" "', argument " "1"" of type '" "SoComplexity *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexity * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexity_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComplexity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComplexity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComplexity_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDrawStyleElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDrawStyleElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoDrawStyleElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDrawStyleElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_initClass", 0, 0, 0)) SWIG_fail;
  SoDrawStyleElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyleElement_init" "', argument " "1"" of type '" "SoDrawStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyleElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoDrawStyleElement::Style arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyleElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDrawStyleElement_set" "', argument " "3"" of type '" "SoDrawStyleElement::Style""'");
  } 
  arg3 = static_cast< SoDrawStyleElement::Style >(val3);
  SoDrawStyleElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoDrawStyleElement::Style arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDrawStyleElement_set" "', argument " "2"" of type '" "SoDrawStyleElement::Style""'");
  } 
  arg2 = static_cast< SoDrawStyleElement::Style >(val2);
  SoDrawStyleElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoDrawStyleElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoDrawStyleElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDrawStyleElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDrawStyleElement::set(SoState *const,SoNode *const,SoDrawStyleElement::Style const)\n"
    "    SoDrawStyleElement::set(SoState *const,SoDrawStyleElement::Style const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDrawStyleElement::Style result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyleElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoDrawStyleElement::Style)SoDrawStyleElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyleElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyleElement::Style result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyleElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoDrawStyleElement::Style)SoDrawStyleElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDrawStyleElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDrawStyleElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoSFUShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFUShort", 0, 0, 0)) SWIG_fail;
  result = (SoSFUShort *)new SoSFUShort();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFUShort, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFUShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFUShort" "', argument " "1"" of type '" "SoSFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFUShort::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFUShort::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_getTypeId" "', argument " "1"" of type '" "SoSFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  result = ((SoSFUShort const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_copyFrom" "', argument " "1"" of type '" "SoSFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_isSame" "', argument " "1"" of type '" "SoSFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFUShort const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_getValue" "', argument " "1"" of type '" "SoSFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  result = (unsigned short)((SoSFUShort const *)arg1)->getValue();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_setValue" "', argument " "1"" of type '" "SoSFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFUShort_setValue" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  SoSFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort___eq__" "', argument " "1"" of type '" "SoSFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFUShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUShort___eq__" "', argument " "2"" of type '" "SoSFUShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUShort___eq__" "', argument " "2"" of type '" "SoSFUShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFUShort * >(argp2);
  result = (int)((SoSFUShort const *)arg1)->operator ==((SoSFUShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFUShort___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  SoSFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort___ne__" "', argument " "1"" of type '" "SoSFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFUShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUShort___ne__" "', argument " "2"" of type '" "SoSFUShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUShort___ne__" "', argument " "2"" of type '" "SoSFUShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFUShort * >(argp2);
  result = (int)((SoSFUShort const *)arg1)->operator !=((SoSFUShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUShort_initClass", 0, 0, 0)) SWIG_fail;
  SoSFUShort::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFUShort *arg1 = 0 ;
  SoSFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUShort_setValue" "', argument " "1"" of type '" "SoSFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUShort_setValue" "', argument " "2"" of type '" "SoSFUShort const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFUShort * >(argp2);
  SoSFUShort_setValue__SWIG_1(arg1,(SoSFUShort const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUShort_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFUShort_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFUShort, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFUShort_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFUShort_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFUShort_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFUShort::setValue(unsigned short)\n"
    "    SoSFUShort::setValue(SoSFUShort const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFUShort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFUShort, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFUShort_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFInt32", 0, 0, 0)) SWIG_fail;
  result = (SoSFInt32 *)new SoSFInt32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFInt32" "', argument " "1"" of type '" "SoSFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFInt32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFInt32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_getTypeId" "', argument " "1"" of type '" "SoSFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  result = ((SoSFInt32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_copyFrom" "', argument " "1"" of type '" "SoSFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_isSame" "', argument " "1"" of type '" "SoSFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFInt32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_getValue" "', argument " "1"" of type '" "SoSFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  result = (int32_t)((SoSFInt32 const *)arg1)->getValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_setValue" "', argument " "1"" of type '" "SoSFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFInt32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32___eq__" "', argument " "1"" of type '" "SoSFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFInt32___eq__" "', argument " "2"" of type '" "SoSFInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFInt32___eq__" "', argument " "2"" of type '" "SoSFInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  result = (int)((SoSFInt32 const *)arg1)->operator ==((SoSFInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFInt32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32___ne__" "', argument " "1"" of type '" "SoSFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFInt32___ne__" "', argument " "2"" of type '" "SoSFInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFInt32___ne__" "', argument " "2"" of type '" "SoSFInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  result = (int)((SoSFInt32 const *)arg1)->operator !=((SoSFInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFInt32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFInt32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFInt32 *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFInt32_setValue" "', argument " "1"" of type '" "SoSFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFInt32_setValue" "', argument " "2"" of type '" "SoSFInt32 const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  SoSFInt32_setValue__SWIG_1(arg1,(SoSFInt32 const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFInt32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFInt32_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFInt32, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFInt32_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFInt32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFInt32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFInt32::setValue(int32_t)\n"
    "    SoSFInt32::setValue(SoSFInt32 const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFInt32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFInt32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFInt32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDrawStyle_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDrawStyle::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_getTypeId" "', argument " "1"" of type '" "SoDrawStyle const *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = ((SoDrawStyle const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_initClass", 0, 0, 0)) SWIG_fail;
  SoDrawStyle::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDrawStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDrawStyle", 0, 0, 0)) SWIG_fail;
  result = (SoDrawStyle *)new SoDrawStyle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDrawStyle, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_style_set" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_style_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_style_get" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = (SoSFEnum *)& ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_pointSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_pointSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_pointSize_set" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_pointSize_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->pointSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_pointSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_pointSize_get" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = (SoSFFloat *)& ((arg1)->pointSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_lineWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_lineWidth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_lineWidth_set" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_lineWidth_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->lineWidth = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_lineWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_lineWidth_get" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = (SoSFFloat *)& ((arg1)->lineWidth);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_linePattern_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoSFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_linePattern_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_linePattern_set" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFUShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_linePattern_set" "', argument " "2"" of type '" "SoSFUShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFUShort * >(argp2);
  if (arg1) (arg1)->linePattern = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_linePattern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFUShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_linePattern_get" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = (SoSFUShort *)& ((arg1)->linePattern);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFUShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_linePatternScaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_linePatternScaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_linePatternScaleFactor_set" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_linePatternScaleFactor_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->linePatternScaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_linePatternScaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_linePatternScaleFactor_get" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->linePatternScaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_doAction" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_GLRender" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDrawStyle_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDrawStyle *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDrawStyle_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDrawStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDrawStyle_callback" "', argument " "1"" of type '" "SoDrawStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoDrawStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDrawStyle_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDrawStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDrawStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDrawStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SbByteBuffer *)new SbByteBuffer((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (SbByteBuffer *)new SbByteBuffer((SbByteBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  char *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbByteBuffer" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbByteBuffer *)new SbByteBuffer(SWIG_STD_MOVE(arg1),(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (SbByteBuffer *)new SbByteBuffer(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbByteBuffer *)new SbByteBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  unsigned char *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbByteBuffer" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbByteBuffer" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  result = (SbByteBuffer *)new SbByteBuffer(SWIG_STD_MOVE(arg1),(unsigned char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbByteBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbByteBuffer", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbByteBuffer__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbByteBuffer__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbByteBuffer__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbByteBuffer__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbByteBuffer__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbByteBuffer__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbByteBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbByteBuffer::SbByteBuffer(char const *)\n"
    "    SbByteBuffer::SbByteBuffer(SbByteBuffer const &)\n"
    "    SbByteBuffer::SbByteBuffer(size_t,char const *)\n"
    "    SbByteBuffer::SbByteBuffer(size_t)\n"
    "    SbByteBuffer::SbByteBuffer()\n"
    "    SbByteBuffer::SbByteBuffer(size_t,unsigned char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbByteBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbByteBuffer" "', argument " "1"" of type '" "SbByteBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_isValid" "', argument " "1"" of type '" "SbByteBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (SbBool)((SbByteBuffer const *)arg1)->isValid();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_size" "', argument " "1"" of type '" "SbByteBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = ((SbByteBuffer const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_empty" "', argument " "1"" of type '" "SbByteBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (SbBool)((SbByteBuffer const *)arg1)->empty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  SbByteBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbByteBuffer___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer___eq__" "', argument " "1"" of type '" "SbByteBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbByteBuffer___eq__" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbByteBuffer___eq__" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< SbByteBuffer * >(argp2);
  result = (SbBool)((SbByteBuffer const *)arg1)->operator ==((SbByteBuffer const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  SbByteBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbByteBuffer___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer___iadd__" "', argument " "1"" of type '" "SbByteBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbByteBuffer___iadd__" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbByteBuffer___iadd__" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< SbByteBuffer * >(argp2);
  result = (SbByteBuffer *) &(arg1)->operator +=((SbByteBuffer const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  SbByteBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbByteBuffer_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_push" "', argument " "1"" of type '" "SbByteBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbByteBuffer_push" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbByteBuffer_push" "', argument " "2"" of type '" "SbByteBuffer const &""'"); 
  }
  arg2 = reinterpret_cast< SbByteBuffer * >(argp2);
  (arg1)->push((SbByteBuffer const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_constData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_constData" "', argument " "1"" of type '" "SbByteBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (char *)((SbByteBuffer const *)arg1)->constData();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_data" "', argument " "1"" of type '" "SbByteBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (char *)(arg1)->data();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_invalidBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbByteBuffer_invalidBuffer", 0, 0, 0)) SWIG_fail;
  result = (SbByteBuffer *) &SbByteBuffer::invalidBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbByteBuffer_makeUnique(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbByteBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbByteBuffer_makeUnique" "', argument " "1"" of type '" "SbByteBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  (arg1)->makeUnique();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbByteBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbByteBuffer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbByteBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec3f *)new SbVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[3] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec3f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec3f *)new SbVec3f((float const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbVec3f *)new SbVec3f(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (SbVec3f *)new SbVec3f((SbVec3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = (SbVec3f *)new SbVec3f((SbVec3b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = (SbVec3f *)new SbVec3f((SbVec3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = (SbVec3f *)new SbVec3f((SbVec3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  SbPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbVec3f" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SbVec3f" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3f" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbPlane * >(argp3);
  result = (SbVec3f *)new SbVec3f((SbPlane const &)*arg1,(SbPlane const &)*arg2,(SbPlane const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec3f", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec3f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3f__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3f__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec3f__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SbVec3f__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbVec3f__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec3f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3f::SbVec3f()\n"
    "    SbVec3f::SbVec3f(float const [3])\n"
    "    SbVec3f::SbVec3f(float,float,float)\n"
    "    SbVec3f::SbVec3f(SbVec3d const &)\n"
    "    SbVec3f::SbVec3f(SbVec3b const &)\n"
    "    SbVec3f::SbVec3f(SbVec3s const &)\n"
    "    SbVec3f::SbVec3f(SbVec3i32 const &)\n"
    "    SbVec3f::SbVec3f(SbPlane const &,SbPlane const &,SbPlane const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec3f *) &(arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec3f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbVec3f *) &(arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec3f_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec3f_setValue" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec3f_setValue" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  result = (SbVec3f *) &(arg1)->setValue((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4,(SbVec3f const &)*arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3f *) &(arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3b * >(argp2);
  result = (SbVec3f *) &(arg1)->setValue((SbVec3b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3f *) &(arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_setValue" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3f *) &(arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3f_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3f_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3f_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec3f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbVec3f_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec3f_setValue__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3f::setValue(float const [3])\n"
    "    SbVec3f::setValue(float,float,float)\n"
    "    SbVec3f::setValue(SbVec3f const &,SbVec3f const &,SbVec3f const &,SbVec3f const &)\n"
    "    SbVec3f::setValue(SbVec3d const &)\n"
    "    SbVec3f::setValue(SbVec3b const &)\n"
    "    SbVec3f::setValue(SbVec3s const &)\n"
    "    SbVec3f::setValue(SbVec3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_getValue" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (float *)((SbVec3f const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(fff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_equals" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_equals" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_equals" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3f_equals" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)((SbVec3f const *)arg1)->equals((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_cross(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f_cross", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_cross" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_cross" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_cross" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = ((SbVec3f const *)arg1)->cross((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_dot" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f_dot" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f_dot" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (float)((SbVec3f const *)arg1)->dot((SbVec3f const &)*arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_getClosestAxis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_getClosestAxis" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = ((SbVec3f const *)arg1)->getClosestAxis();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_length" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (float)((SbVec3f const *)arg1)->length();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_sqrLength" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (float)((SbVec3f const *)arg1)->sqrLength();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_normalize" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (float)(arg1)->normalize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_negate" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___imul__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___imul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec3f *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___itruediv__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___itruediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec3f *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___iadd__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___iadd__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___iadd__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3f *) &(arg1)->operator +=((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___isub__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___isub__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___isub__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3f *) &(arg1)->operator -=((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___neg__" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = ((SbVec3f const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_toString" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = ((SbVec3f const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_fromString" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f_output" "', argument " "1"" of type '" "SbVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec3f const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___add__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___add__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___add__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SbVec3f___add__(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___sub__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___sub__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___sub__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SbVec3f___sub__(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___mul__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec3f___mul____SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___mul__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = SbVec3f___mul____SWIG_1(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3f___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3f___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3f___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___rmul__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec3f___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___div__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec3f___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___truediv__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___truediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec3f___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___eq__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___eq__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___eq__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)SbVec3f___eq__(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3f___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___nq__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3f___nq__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3f___nq__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)SbVec3f___nq__(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___getitem__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SbVec3f___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3f___setitem__" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3f___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SbVec3f___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3f" "', argument " "1"" of type '" "SbVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbColor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbColor *)new SbColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbColor" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbColor" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (SbColor *)new SbColor((SbVec3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[3] ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec3f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbColor *)new SbColor((float const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbColor" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbColor" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbColor" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbColor *)new SbColor(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbColor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbColor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbColor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbColor__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbColor__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbColor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor::SbColor()\n"
    "    SbColor::SbColor(SbVec3f const &)\n"
    "    SbColor::SbColor(float const *const)\n"
    "    SbColor::SbColor(float const,float const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_setHSVValue" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbColor_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbColor *) &(arg1)->setHSVValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_setHSVValue" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbColor *) &(arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbColor_setHSVValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbColor_setHSVValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbColor_setHSVValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbColor_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor::setHSVValue(float,float,float)\n"
    "    SbColor::setHSVValue(float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor_getHSVValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_getHSVValue" "', argument " "1"" of type '" "SbColor const *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ((SbColor const *)arg1)->getHSVValue(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_setPackedValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  uint32_t arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor_setPackedValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_setPackedValue" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor_setPackedValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbColor_setPackedValue" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor_setPackedValue" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  result = (SbColor *) &(arg1)->setPackedValue(arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_getPackedValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_getPackedValue" "', argument " "1"" of type '" "SbColor const *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor_getPackedValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (uint32_t)((SbColor const *)arg1)->getPackedValue(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_getPackedValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor_getPackedValue" "', argument " "1"" of type '" "SbColor const *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  result = (uint32_t)((SbColor const *)arg1)->getPackedValue();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor_getPackedValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbColor_getPackedValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbColor_getPackedValue__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbColor_getPackedValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbColor_getPackedValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor::getPackedValue(float const) const\n"
    "    SbColor::getPackedValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___add__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor___add__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor___add__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = SbColor___add__(arg1,(SbColor const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___sub__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor___sub__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor___sub__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = SbColor___sub__(arg1,(SbColor const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___mul__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___rmul__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___div__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___eq__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor___eq__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor___eq__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = (int)SbColor___eq__(arg1,(SbColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___nq__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor___nq__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor___nq__" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = (int)SbColor___nq__(arg1,(SbColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___getitem__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SbColor___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor___setitem__" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SbColor___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbColor" "', argument " "1"" of type '" "SbColor *""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLazyElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLazyElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLazyElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLazyElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLazyElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_init" "', argument " "1"" of type '" "SoLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_push" "', argument " "1"" of type '" "SoLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_matches" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoLazyElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_copyMatchInfo" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (SoElement *)((SoLazyElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setToDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setToDefault" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLazyElement::setToDefault(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setDiffuse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  SbColor *arg4 = 0 ;
  SoColorPacker *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setDiffuse", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setDiffuse" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setDiffuse" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_setDiffuse" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLazyElement_setDiffuse" "', argument " "4"" of type '" "SbColor const *""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoLazyElement_setDiffuse" "', argument " "5"" of type '" "SoColorPacker *""'"); 
  }
  arg5 = reinterpret_cast< SoColorPacker * >(argp5);
  SoLazyElement::setDiffuse(arg1,arg2,arg3,(SbColor const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  float *arg4 = 0 ;
  SoColorPacker *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setTransparency", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setTransparency" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setTransparency" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_setTransparency" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLazyElement_setTransparency" "', argument " "4"" of type '" "float const *""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoLazyElement_setTransparency" "', argument " "5"" of type '" "SoColorPacker *""'"); 
  }
  arg5 = reinterpret_cast< SoColorPacker * >(argp5);
  SoLazyElement::setTransparency(arg1,arg2,arg3,(float const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setColorIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setColorIndices", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setColorIndices" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setColorIndices" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_setColorIndices" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLazyElement_setColorIndices" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  SoLazyElement::setColorIndices(arg1,arg2,arg3,(int const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setAmbient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setAmbient", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setAmbient" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setAmbient" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  SoLazyElement::setAmbient(arg1,(SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setEmissive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setEmissive", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setEmissive" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setEmissive" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  SoLazyElement::setEmissive(arg1,(SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setSpecular(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setSpecular", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setSpecular" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setSpecular" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  SoLazyElement::setSpecular(arg1,(SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setShininess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setShininess", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setShininess" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setShininess" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoLazyElement::setShininess(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setColorMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setColorMaterial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setColorMaterial" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setColorMaterial" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoLazyElement::setColorMaterial(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_enableBlending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_enableBlending", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_enableBlending" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_enableBlending" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_enableBlending" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoLazyElement::enableBlending(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_enableSeparateBlending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_enableSeparateBlending", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_enableSeparateBlending" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_enableSeparateBlending" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_enableSeparateBlending" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoLazyElement_enableSeparateBlending" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoLazyElement_enableSeparateBlending" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  SoLazyElement::enableSeparateBlending(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_disableBlending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_disableBlending" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLazyElement::disableBlending(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setLightModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setLightModel" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setLightModel" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoLazyElement::setLightModel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setVertexOrdering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoLazyElement::VertexOrdering arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setVertexOrdering", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setVertexOrdering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setVertexOrdering" "', argument " "2"" of type '" "SoLazyElement::VertexOrdering""'");
  } 
  arg2 = static_cast< SoLazyElement::VertexOrdering >(val2);
  SoLazyElement::setVertexOrdering(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setBackfaceCulling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setBackfaceCulling", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setBackfaceCulling" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setBackfaceCulling" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoLazyElement::setBackfaceCulling(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setTwosideLighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setTwosideLighting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setTwosideLighting" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setTwosideLighting" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoLazyElement::setTwosideLighting(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setShadeModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setShadeModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setShadeModel" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setShadeModel" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoLazyElement::setShadeModel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setAlphaTest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setAlphaTest", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setAlphaTest" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setAlphaTest" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_setAlphaTest" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoLazyElement::setAlphaTest(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDiffuse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDiffuse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getDiffuse" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_getDiffuse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &SoLazyElement::getDiffuse(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getTransparency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getTransparency" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_getTransparency" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SoLazyElement::getTransparency(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getPackedColors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getPackedColors" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (uint32_t *)SoLazyElement::getPackedColors(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getColorIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getColorIndices" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t *)SoLazyElement::getColorIndices(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getColorIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getColorIndex" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_getColorIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int32_t)SoLazyElement::getColorIndex(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getAmbient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getAmbient" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoLazyElement::getAmbient(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getEmissive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getEmissive" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoLazyElement::getEmissive(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getSpecular(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getSpecular" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoLazyElement::getSpecular(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getShininess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getShininess" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoLazyElement::getShininess(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getColorMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getColorMaterial" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoLazyElement::getColorMaterial(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getBlending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getBlending", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getBlending" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_getBlending" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_getBlending" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoLazyElement_getBlending" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_getBlending" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (SbBool)SoLazyElement::getBlending(arg1,*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getAlphaBlending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getAlphaBlending", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getAlphaBlending" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_getAlphaBlending" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_getAlphaBlending" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoLazyElement_getAlphaBlending" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_getAlphaBlending" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (SbBool)SoLazyElement::getAlphaBlending(arg1,*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getLightModel" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoLazyElement::getLightModel(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getAlphaTest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getAlphaTest", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getAlphaTest" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_getAlphaTest" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_getAlphaTest" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  result = (int)SoLazyElement::getAlphaTest(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getTwoSidedLighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getTwoSidedLighting" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoLazyElement::getTwoSidedLighting(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getNumDiffuse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getNumDiffuse" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (int32_t)((SoLazyElement const *)arg1)->getNumDiffuse();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getNumTransparencies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getNumTransparencies" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (int32_t)((SoLazyElement const *)arg1)->getNumTransparencies();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getNumColorIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getNumColorIndices" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (int32_t)((SoLazyElement const *)arg1)->getNumColorIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_isPacked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_isPacked" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (SbBool)((SoLazyElement const *)arg1)->isPacked();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_isTransparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_isTransparent" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (SbBool)((SoLazyElement const *)arg1)->isTransparent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoLazyElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoLazyElement *)SoLazyElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLazyElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultAmbientIntensity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultAmbientIntensity", 0, 0, 0)) SWIG_fail;
  result = (float)SoLazyElement::getDefaultAmbientIntensity();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultDiffuse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultDiffuse", 0, 0, 0)) SWIG_fail;
  result = SoLazyElement::getDefaultDiffuse();
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultAmbient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultAmbient", 0, 0, 0)) SWIG_fail;
  result = SoLazyElement::getDefaultAmbient();
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultSpecular(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultSpecular", 0, 0, 0)) SWIG_fail;
  result = SoLazyElement::getDefaultSpecular();
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultEmissive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultEmissive", 0, 0, 0)) SWIG_fail;
  result = SoLazyElement::getDefaultEmissive();
  resultobj = SWIG_NewPointerObj((new SbColor(result)), SWIGTYPE_p_SbColor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultShininess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultShininess", 0, 0, 0)) SWIG_fail;
  result = (float)SoLazyElement::getDefaultShininess();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultPacked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultPacked", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoLazyElement::getDefaultPacked();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultTransparency", 0, 0, 0)) SWIG_fail;
  result = (float)SoLazyElement::getDefaultTransparency();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultLightModel", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoLazyElement::getDefaultLightModel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDefaultColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_getDefaultColorIndex", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoLazyElement::getDefaultColorIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setMaterials(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  uint32_t arg3 ;
  SoColorPacker *arg4 = 0 ;
  SbColor *arg5 = 0 ;
  int arg6 ;
  float *arg7 = 0 ;
  int arg8 ;
  SbColor *arg9 = 0 ;
  SbColor *arg10 = 0 ;
  SbColor *arg11 = 0 ;
  float arg12 ;
  SbBool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject *swig_obj[13] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setMaterials", 13, 13, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setMaterials" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLazyElement_setMaterials" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLazyElement_setMaterials" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLazyElement_setMaterials" "', argument " "4"" of type '" "SoColorPacker *""'"); 
  }
  arg4 = reinterpret_cast< SoColorPacker * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoLazyElement_setMaterials" "', argument " "5"" of type '" "SbColor const *""'"); 
  }
  arg5 = reinterpret_cast< SbColor * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoLazyElement_setMaterials" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoLazyElement_setMaterials" "', argument " "7"" of type '" "float const *""'"); 
  }
  arg7 = reinterpret_cast< float * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoLazyElement_setMaterials" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoLazyElement_setMaterials" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_setMaterials" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  arg9 = reinterpret_cast< SbColor * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoLazyElement_setMaterials" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_setMaterials" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SoLazyElement_setMaterials" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLazyElement_setMaterials" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  arg11 = reinterpret_cast< SbColor * >(argp11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoLazyElement_setMaterials" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SoLazyElement_setMaterials" "', argument " "13"" of type '" "SbBool""'");
  } 
  arg13 = static_cast< SbBool >(val13);
  SoLazyElement::setMaterials(arg1,arg2,arg3,arg4,(SbColor const *)arg5,arg6,(float const *)arg7,arg8,(SbColor const &)*arg9,(SbColor const &)*arg10,(SbColor const &)*arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getWInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoLazyElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getWInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoLazyElement *)SoLazyElement::getWInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLazyElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getPackedPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getPackedPointer" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (uint32_t *)((SoLazyElement const *)arg1)->getPackedPointer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getDiffusePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getDiffusePointer" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (SbColor *)((SoLazyElement const *)arg1)->getDiffusePointer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getColorIndexPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getColorIndexPointer" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (int32_t *)((SoLazyElement const *)arg1)->getColorIndexPointer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_getTransparencyPointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_getTransparencyPointer" "', argument " "1"" of type '" "SoLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLazyElement * >(argp1);
  result = (float *)((SoLazyElement const *)arg1)->getTransparencyPointer();
  {
    resultobj = Py_BuildValue("(fff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLazyElement_setTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLazyElement_setTransparencyType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLazyElement_setTransparencyType" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLazyElement_setTransparencyType" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoLazyElement::setTransparencyType(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLazyElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLazyElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoColorPacker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoColorPacker", 0, 0, 0)) SWIG_fail;
  result = (SoColorPacker *)new SoColorPacker();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoColorPacker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoColorPacker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoColorPacker" "', argument " "1"" of type '" "SoColorPacker *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_getPackedColors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_getPackedColors" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  result = (uint32_t *)((SoColorPacker const *)arg1)->getPackedColors();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_diffuseMatch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  SbUniqueId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorPacker_diffuseMatch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_diffuseMatch" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoColorPacker_diffuseMatch" "', argument " "2"" of type '" "SbUniqueId""'");
  } 
  arg2 = static_cast< SbUniqueId >(val2);
  result = (SbBool)((SoColorPacker const *)arg1)->diffuseMatch(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_transpMatch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  SbUniqueId arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorPacker_transpMatch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_transpMatch" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoColorPacker_transpMatch" "', argument " "2"" of type '" "SbUniqueId""'");
  } 
  arg2 = static_cast< SbUniqueId >(val2);
  result = (SbBool)((SoColorPacker const *)arg1)->transpMatch(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_setNodeIds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  SbUniqueId arg2 ;
  SbUniqueId arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorPacker_setNodeIds", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_setNodeIds" "', argument " "1"" of type '" "SoColorPacker *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoColorPacker_setNodeIds" "', argument " "2"" of type '" "SbUniqueId""'");
  } 
  arg2 = static_cast< SbUniqueId >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoColorPacker_setNodeIds" "', argument " "3"" of type '" "SbUniqueId""'");
  } 
  arg3 = static_cast< SbUniqueId >(val3);
  (arg1)->setNodeIds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_getSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_getSize" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  result = (int32_t)((SoColorPacker const *)arg1)->getSize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_reallocate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorPacker_reallocate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_reallocate" "', argument " "1"" of type '" "SoColorPacker *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoColorPacker_reallocate" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  (arg1)->reallocate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_getDiffuseId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_getDiffuseId" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  result = (SbUniqueId)((SoColorPacker const *)arg1)->getDiffuseId();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorPacker_getTranspId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorPacker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorPacker_getTranspId" "', argument " "1"" of type '" "SoColorPacker const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorPacker * >(argp1);
  result = (SbUniqueId)((SoColorPacker const *)arg1)->getTranspId();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoColorPacker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoColorPacker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoColorPacker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLightModel_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLightModel::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_getTypeId" "', argument " "1"" of type '" "SoLightModel const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  result = ((SoLightModel const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_initClass", 0, 0, 0)) SWIG_fail;
  SoLightModel::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLightModel", 0, 0, 0)) SWIG_fail;
  result = (SoLightModel *)new SoLightModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLightModel, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_model_set" "', argument " "1"" of type '" "SoLightModel *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModel_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_model_get" "', argument " "1"" of type '" "SoLightModel *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_doAction" "', argument " "1"" of type '" "SoLightModel *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModel_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_GLRender" "', argument " "1"" of type '" "SoLightModel *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModel_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModel_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModel *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModel_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModel_callback" "', argument " "1"" of type '" "SoLightModel *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModel_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLightModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMaterialBindingElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoMaterialBindingElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMaterialBindingElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_initClass", 0, 0, 0)) SWIG_fail;
  SoMaterialBindingElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBindingElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBindingElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBindingElement_init" "', argument " "1"" of type '" "SoMaterialBindingElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBindingElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBindingElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoMaterialBindingElement::Binding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBindingElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMaterialBindingElement_set" "', argument " "3"" of type '" "SoMaterialBindingElement::Binding""'");
  } 
  arg3 = static_cast< SoMaterialBindingElement::Binding >(val3);
  SoMaterialBindingElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoMaterialBindingElement::Binding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMaterialBindingElement_set" "', argument " "2"" of type '" "SoMaterialBindingElement::Binding""'");
  } 
  arg2 = static_cast< SoMaterialBindingElement::Binding >(val2);
  SoMaterialBindingElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMaterialBindingElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMaterialBindingElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMaterialBindingElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMaterialBindingElement::set(SoState *const,SoNode *const,SoMaterialBindingElement::Binding const)\n"
    "    SoMaterialBindingElement::set(SoState *const,SoMaterialBindingElement::Binding const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMaterialBindingElement::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBindingElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMaterialBindingElement::Binding)SoMaterialBindingElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBindingElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBindingElement::Binding result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBindingElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoMaterialBindingElement::Binding)SoMaterialBindingElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMaterialBindingElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMaterialBindingElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoMaterialBinding_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMaterialBinding::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_getTypeId" "', argument " "1"" of type '" "SoMaterialBinding const *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  result = ((SoMaterialBinding const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_initClass", 0, 0, 0)) SWIG_fail;
  SoMaterialBinding::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMaterialBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMaterialBinding", 0, 0, 0)) SWIG_fail;
  result = (SoMaterialBinding *)new SoMaterialBinding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMaterialBinding, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_value_set" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_value_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_value_get" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  result = (SoSFEnum *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_doAction" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_GLRender" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_callback" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_pick" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBinding_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBinding *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBinding_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBinding_getPrimitiveCount" "', argument " "1"" of type '" "SoMaterialBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterialBinding_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMaterialBinding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMaterialBinding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMaterialBinding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNormalBindingElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNormalBindingElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoNormalBindingElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoNormalBindingElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_initClass", 0, 0, 0)) SWIG_fail;
  SoNormalBindingElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBindingElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBindingElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBindingElement_init" "', argument " "1"" of type '" "SoNormalBindingElement *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBindingElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBindingElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoNormalBindingElement::Binding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBindingElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalBindingElement_set" "', argument " "3"" of type '" "SoNormalBindingElement::Binding""'");
  } 
  arg3 = static_cast< SoNormalBindingElement::Binding >(val3);
  SoNormalBindingElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNormalBindingElement::Binding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalBindingElement_set" "', argument " "2"" of type '" "SoNormalBindingElement::Binding""'");
  } 
  arg2 = static_cast< SoNormalBindingElement::Binding >(val2);
  SoNormalBindingElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNormalBindingElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoNormalBindingElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNormalBindingElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalBindingElement::set(SoState *const,SoNode *const,SoNormalBindingElement::Binding const)\n"
    "    SoNormalBindingElement::set(SoState *const,SoNormalBindingElement::Binding const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNormalBindingElement::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBindingElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoNormalBindingElement::Binding)SoNormalBindingElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBindingElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBindingElement::Binding result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBindingElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoNormalBindingElement::Binding)SoNormalBindingElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalBindingElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalBindingElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoNormalBinding_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNormalBinding::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_getTypeId" "', argument " "1"" of type '" "SoNormalBinding const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  result = ((SoNormalBinding const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_initClass", 0, 0, 0)) SWIG_fail;
  SoNormalBinding::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNormalBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNormalBinding", 0, 0, 0)) SWIG_fail;
  result = (SoNormalBinding *)new SoNormalBinding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalBinding, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_value_set" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_value_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_value_get" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  result = (SoSFEnum *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_doAction" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_GLRender" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_callback" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_pick" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBinding_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBinding *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBinding_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBinding_getPrimitiveCount" "', argument " "1"" of type '" "SoNormalBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBinding_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalBinding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalBinding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNormalBinding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPickStyleElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPickStyleElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoPickStyleElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoPickStyleElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_initClass", 0, 0, 0)) SWIG_fail;
  SoPickStyleElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyleElement_init" "', argument " "1"" of type '" "SoPickStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyleElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyleElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPickStyleElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoPickStyleElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoPickStyleElement::Style arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickStyleElement_set" "', argument " "2"" of type '" "SoPickStyleElement::Style""'");
  } 
  arg2 = static_cast< SoPickStyleElement::Style >(val2);
  SoPickStyleElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickStyleElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPickStyleElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoPickStyleElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickStyleElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickStyleElement::set(SoState *const,SoNode *const,int32_t const)\n"
    "    SoPickStyleElement::set(SoState *const,SoPickStyleElement::Style const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickStyleElement::Style result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyleElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoPickStyleElement::Style)SoPickStyleElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyleElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyleElement::Style result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyleElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoPickStyleElement::Style)SoPickStyleElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickStyleElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickStyleElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoPickStyle_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPickStyle::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_getTypeId" "', argument " "1"" of type '" "SoPickStyle const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  result = ((SoPickStyle const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_initClass", 0, 0, 0)) SWIG_fail;
  SoPickStyle::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPickStyle", 0, 0, 0)) SWIG_fail;
  result = (SoPickStyle *)new SoPickStyle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickStyle, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_style_set" "', argument " "1"" of type '" "SoPickStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyle_style_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_style_get" "', argument " "1"" of type '" "SoPickStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  result = (SoSFEnum *)& ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_doAction" "', argument " "1"" of type '" "SoPickStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyle_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_callback" "', argument " "1"" of type '" "SoPickStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyle_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickStyle_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickStyle *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickStyle_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickStyle_pick" "', argument " "1"" of type '" "SoPickStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoPickStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickStyle_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPickStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShapeHintsElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoShapeHintsElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoShapeHintsElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_initClass", 0, 0, 0)) SWIG_fail;
  SoShapeHintsElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_init" "', argument " "1"" of type '" "SoShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_push" "', argument " "1"" of type '" "SoShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_pop" "', argument " "1"" of type '" "SoShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShapeHintsElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_matches" "', argument " "1"" of type '" "SoShapeHintsElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoShapeHintsElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_copyMatchInfo" "', argument " "1"" of type '" "SoShapeHintsElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  result = (SoElement *)((SoShapeHintsElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoShapeHintsElement::VertexOrdering arg3 ;
  SoShapeHintsElement::ShapeType arg4 ;
  SoShapeHintsElement::FaceType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoShapeHintsElement_set" "', argument " "3"" of type '" "SoShapeHintsElement::VertexOrdering""'");
  } 
  arg3 = static_cast< SoShapeHintsElement::VertexOrdering >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoShapeHintsElement_set" "', argument " "4"" of type '" "SoShapeHintsElement::ShapeType""'");
  } 
  arg4 = static_cast< SoShapeHintsElement::ShapeType >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoShapeHintsElement_set" "', argument " "5"" of type '" "SoShapeHintsElement::FaceType""'");
  } 
  arg5 = static_cast< SoShapeHintsElement::FaceType >(val5);
  SoShapeHintsElement::set(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoShapeHintsElement::VertexOrdering arg2 ;
  SoShapeHintsElement::ShapeType arg3 ;
  SoShapeHintsElement::FaceType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeHintsElement_set" "', argument " "2"" of type '" "SoShapeHintsElement::VertexOrdering""'");
  } 
  arg2 = static_cast< SoShapeHintsElement::VertexOrdering >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoShapeHintsElement_set" "', argument " "3"" of type '" "SoShapeHintsElement::ShapeType""'");
  } 
  arg3 = static_cast< SoShapeHintsElement::ShapeType >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoShapeHintsElement_set" "', argument " "4"" of type '" "SoShapeHintsElement::FaceType""'");
  } 
  arg4 = static_cast< SoShapeHintsElement::FaceType >(val4);
  SoShapeHintsElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_set", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoShapeHintsElement_set__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoShapeHintsElement_set__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoShapeHintsElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoShapeHintsElement::set(SoState *const,SoNode *const,SoShapeHintsElement::VertexOrdering const,SoShapeHintsElement::ShapeType const,SoShapeHintsElement::FaceType const)\n"
    "    SoShapeHintsElement::set(SoState *const,SoShapeHintsElement::VertexOrdering const,SoShapeHintsElement::ShapeType const,SoShapeHintsElement::FaceType const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoShapeHintsElement::VertexOrdering *arg2 = 0 ;
  SoShapeHintsElement::ShapeType *arg3 = 0 ;
  SoShapeHintsElement::FaceType *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_get", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoShapeHintsElement__VertexOrdering,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHintsElement_get" "', argument " "2"" of type '" "SoShapeHintsElement::VertexOrdering &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShapeHintsElement_get" "', argument " "2"" of type '" "SoShapeHintsElement::VertexOrdering &""'"); 
  }
  arg2 = reinterpret_cast< SoShapeHintsElement::VertexOrdering * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoShapeHintsElement__ShapeType,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShapeHintsElement_get" "', argument " "3"" of type '" "SoShapeHintsElement::ShapeType &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShapeHintsElement_get" "', argument " "3"" of type '" "SoShapeHintsElement::ShapeType &""'"); 
  }
  arg3 = reinterpret_cast< SoShapeHintsElement::ShapeType * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoShapeHintsElement__FaceType,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoShapeHintsElement_get" "', argument " "4"" of type '" "SoShapeHintsElement::FaceType &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShapeHintsElement_get" "', argument " "4"" of type '" "SoShapeHintsElement::FaceType &""'"); 
  }
  arg4 = reinterpret_cast< SoShapeHintsElement::FaceType * >(argp4);
  SoShapeHintsElement::get(arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getVertexOrdering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHintsElement::VertexOrdering result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_getVertexOrdering" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoShapeHintsElement::VertexOrdering)SoShapeHintsElement::getVertexOrdering(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getShapeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHintsElement::ShapeType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_getShapeType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoShapeHintsElement::ShapeType)SoShapeHintsElement::getShapeType(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getFaceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHintsElement::FaceType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_getFaceType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoShapeHintsElement::FaceType)SoShapeHintsElement::getFaceType(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getDefaultVertexOrdering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement::VertexOrdering result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_getDefaultVertexOrdering", 0, 0, 0)) SWIG_fail;
  result = (SoShapeHintsElement::VertexOrdering)SoShapeHintsElement::getDefaultVertexOrdering();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getDefaultShapeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement::ShapeType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_getDefaultShapeType", 0, 0, 0)) SWIG_fail;
  result = (SoShapeHintsElement::ShapeType)SoShapeHintsElement::getDefaultShapeType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_getDefaultFaceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement::FaceType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_getDefaultFaceType", 0, 0, 0)) SWIG_fail;
  result = (SoShapeHintsElement::FaceType)SoShapeHintsElement::getDefaultFaceType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHintsElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHintsElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHintsElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHintsElement_output" "', argument " "1"" of type '" "SoShapeHintsElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHintsElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoShapeHintsElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShapeHintsElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShapeHintsElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoSFBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBool", 0, 0, 0)) SWIG_fail;
  result = (SoSFBool *)new SoSFBool();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBool" "', argument " "1"" of type '" "SoSFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBool::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBool::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_getTypeId" "', argument " "1"" of type '" "SoSFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  result = ((SoSFBool const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_copyFrom" "', argument " "1"" of type '" "SoSFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBool_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBool_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_isSame" "', argument " "1"" of type '" "SoSFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBool_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBool_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBool const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_getValue" "', argument " "1"" of type '" "SoSFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  result = (SbBool)((SoSFBool const *)arg1)->getValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_setValue" "', argument " "1"" of type '" "SoSFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBool_setValue" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool___eq__" "', argument " "1"" of type '" "SoSFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBool,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBool___eq__" "', argument " "2"" of type '" "SoSFBool const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBool___eq__" "', argument " "2"" of type '" "SoSFBool const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  result = (int)((SoSFBool const *)arg1)->operator ==((SoSFBool const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBool___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool___ne__" "', argument " "1"" of type '" "SoSFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBool,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBool___ne__" "', argument " "2"" of type '" "SoSFBool const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBool___ne__" "', argument " "2"" of type '" "SoSFBool const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  result = (int)((SoSFBool const *)arg1)->operator !=((SoSFBool const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBool_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBool_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBool::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBool *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBool_setValue" "', argument " "1"" of type '" "SoSFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBool_setValue" "', argument " "2"" of type '" "SoSFBool const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  SoSFBool_setValue__SWIG_1(arg1,(SoSFBool const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBool_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBool_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFBool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBool_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFBool_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBool_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBool::setValue(SbBool)\n"
    "    SoSFBool::setValue(SoSFBool const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBool, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShapeHints_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShapeHints::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_getTypeId" "', argument " "1"" of type '" "SoShapeHints const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = ((SoShapeHints const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_initClass", 0, 0, 0)) SWIG_fail;
  SoShapeHints::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShapeHints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShapeHints", 0, 0, 0)) SWIG_fail;
  result = (SoShapeHints *)new SoShapeHints();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShapeHints, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_vertexOrdering_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_vertexOrdering_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_vertexOrdering_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_vertexOrdering_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->vertexOrdering = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_vertexOrdering_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_vertexOrdering_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFEnum *)& ((arg1)->vertexOrdering);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_shapeType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_shapeType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_shapeType_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_shapeType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->shapeType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_shapeType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_shapeType_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFEnum *)& ((arg1)->shapeType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_faceType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_faceType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_faceType_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_faceType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->faceType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_faceType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_faceType_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFEnum *)& ((arg1)->faceType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_windingType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_windingType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_windingType_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_windingType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->windingType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_windingType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_windingType_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFEnum *)& ((arg1)->windingType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_useVBO_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_useVBO_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_useVBO_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_useVBO_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->useVBO = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_useVBO_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_useVBO_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFBool *)& ((arg1)->useVBO);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_creaseAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_creaseAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_creaseAngle_set" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_creaseAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->creaseAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_creaseAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_creaseAngle_get" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  result = (SoSFFloat *)& ((arg1)->creaseAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_doAction" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_GLRender" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_callback" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_getBoundingBox" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeHints_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeHints *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeHints_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeHints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeHints_pick" "', argument " "1"" of type '" "SoShapeHints *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeHints * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeHints_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShapeHints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShapeHints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShapeHints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTexture_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture_getTypeId" "', argument " "1"" of type '" "SoTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture * >(argp1);
  result = ((SoTexture const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoTexture::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture_doAction" "', argument " "1"" of type '" "SoTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture_GLRender" "', argument " "1"" of type '" "SoTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture_callback" "', argument " "1"" of type '" "SoTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoSFImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFImage", 0, 0, 0)) SWIG_fail;
  result = (SoSFImage *)new SoSFImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFImage" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFImage::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFImage::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_getTypeId" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = ((SoSFImage const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_copyFrom" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_isSame" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFImage const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_initClass", 0, 0, 0)) SWIG_fail;
  SoSFImage::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  unsigned char *result = 0 ;
  
  {
    arg2 = new SbVec2s();
    arg3 = &temp2;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_getValue" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = (unsigned char *)((SoSFImage const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = Py_BuildValue("(s#Oi)",
      (const char *)result,
      (*arg2)[0] * (*arg2)[1] * (*arg3),
      SWIG_NewPointerObj((void *)arg2, SWIGTYPE_p_SbVec2s, 1),
      *arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_getValue" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = (SbImage *) &((SoSFImage const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFImage_getValue", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFImage_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFImage_getValue__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFImage_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFImage::getValue(SbVec2s &,int &) const\n"
    "    SoSFImage::getValue() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  SoSFImage::CopyPolicy arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setValue" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFImage_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFImage_setValue" "', argument " "4"" of type '" "unsigned char const *""'"); 
  }
  arg4 = reinterpret_cast< unsigned char * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFImage_setValue" "', argument " "5"" of type '" "SoSFImage::CopyPolicy""'");
  } 
  arg5 = static_cast< SoSFImage::CopyPolicy >(val5);
  (arg1)->setValue((SbVec2s const &)*arg2,arg3,(unsigned char const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setValue" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFImage_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFImage_setValue" "', argument " "4"" of type '" "unsigned char const *""'"); 
  }
  arg4 = reinterpret_cast< unsigned char * >(argp4);
  (arg1)->setValue((SbVec2s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage___eq__" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFImage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage___eq__" "', argument " "2"" of type '" "SoSFImage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage___eq__" "', argument " "2"" of type '" "SoSFImage const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  result = (int)((SoSFImage const *)arg1)->operator ==((SoSFImage const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFImage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage___ne__" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFImage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage___ne__" "', argument " "2"" of type '" "SoSFImage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage___ne__" "', argument " "2"" of type '" "SoSFImage const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  result = (int)((SoSFImage const *)arg1)->operator !=((SoSFImage const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFImage_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject *swig_obj[1] ;
  unsigned char *result = 0 ;
  
  {
    arg2 = new SbVec2s();
    arg3 = &temp2;
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_startEditing" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = (unsigned char *)(arg1)->startEditing(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = Py_BuildValue("(s#Oi)",
      (const char *)result,
      (*arg2)[0] * (*arg2)[1] * (*arg3),
      SWIG_NewPointerObj((void *)arg2, SWIGTYPE_p_SbVec2s, 1),
      *arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_finishEditing" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setSubValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_setSubValue", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setSubValue" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setSubValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_setSubValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFImage_setSubValue" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_setSubValue" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFImage_setSubValue" "', argument " "4"" of type '" "unsigned char *""'"); 
  }
  arg4 = reinterpret_cast< unsigned char * >(argp4);
  (arg1)->setSubValue((SbVec2s const &)*arg2,(SbVec2s const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setSubValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  unsigned char **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_setSubValues", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setSubValues" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setSubValues" "', argument " "2"" of type '" "SbVec2s const *""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFImage_setSubValues" "', argument " "3"" of type '" "SbVec2s const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFImage_setSubValues" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoSFImage_setSubValues" "', argument " "5"" of type '" "unsigned char **""'"); 
  }
  arg5 = reinterpret_cast< unsigned char ** >(argp5);
  (arg1)->setSubValues((SbVec2s const *)arg2,(SbVec2s const *)arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_getSubTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  int arg2 ;
  SbVec2s *arg3 = 0 ;
  SbVec2s *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  unsigned char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_getSubTexture", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_getSubTexture" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFImage_getSubTexture" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFImage_getSubTexture" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_getSubTexture" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFImage_getSubTexture" "', argument " "4"" of type '" "SbVec2s &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_getSubTexture" "', argument " "4"" of type '" "SbVec2s &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2s * >(argp4);
  result = (unsigned char *)((SoSFImage const *)arg1)->getSubTexture(arg2,*arg3,*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_hasSubTextures(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_hasSubTextures", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_hasSubTextures" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_hasSubTextures" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_hasSubTextures" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SbBool)(arg1)->hasSubTextures(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setNeverWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage_setNeverWrite", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setNeverWrite" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFImage_setNeverWrite" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setNeverWrite(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_isNeverWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_isNeverWrite" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = (SbBool)((SoSFImage const *)arg1)->isNeverWrite();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_hasTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_hasTransparency" "', argument " "1"" of type '" "SoSFImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  result = (SbBool)((SoSFImage const *)arg1)->hasTransparency();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setValue" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFImage_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  arg4 = swig_obj[3];
  SoSFImage_setValue__SWIG_2(arg1,(SbVec2s const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage_setValue" "', argument " "1"" of type '" "SoSFImage *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage_setValue" "', argument " "2"" of type '" "SoSFImage const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  SoSFImage_setValue__SWIG_3(arg1,(SoSFImage const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFImage_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFImage_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoSFImage_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoSFImage_setValue__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFImage_setValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFImage_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFImage::setValue(SbVec2s const &,int const,unsigned char const *,SoSFImage::CopyPolicy)\n"
    "    SoSFImage::setValue(SbVec2s const &,int const,unsigned char const *)\n"
    "    SoSFImage::setValue(SbVec2s const &,int const,PyObject *)\n"
    "    SoSFImage::setValue(SoSFImage const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFImage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFString", 0, 0, 0)) SWIG_fail;
  result = (SoSFString *)new SoSFString();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFString" "', argument " "1"" of type '" "SoSFString *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFString::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFString::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_getTypeId" "', argument " "1"" of type '" "SoSFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  result = ((SoSFString const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_copyFrom" "', argument " "1"" of type '" "SoSFString *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFString_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_isSame" "', argument " "1"" of type '" "SoSFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFString_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFString const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_getValue" "', argument " "1"" of type '" "SoSFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  result = (SbString *) &((SoSFString const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_setValue" "', argument " "1"" of type '" "SoSFString *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString___eq__" "', argument " "1"" of type '" "SoSFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFString,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString___eq__" "', argument " "2"" of type '" "SoSFString const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFString___eq__" "', argument " "2"" of type '" "SoSFString const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  result = (int)((SoSFString const *)arg1)->operator ==((SoSFString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFString___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString___ne__" "', argument " "1"" of type '" "SoSFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFString,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString___ne__" "', argument " "2"" of type '" "SoSFString const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFString___ne__" "', argument " "2"" of type '" "SoSFString const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  result = (int)((SoSFString const *)arg1)->operator !=((SoSFString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFString_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFString_initClass", 0, 0, 0)) SWIG_fail;
  SoSFString::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_setValue" "', argument " "1"" of type '" "SoSFString *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString_setValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setValue((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFString *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFString_setValue" "', argument " "1"" of type '" "SoSFString *""'"); 
  }
  arg1 = reinterpret_cast< SoSFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFString_setValue" "', argument " "2"" of type '" "SoSFString const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  SoSFString_setValue__SWIG_2(arg1,(SoSFString const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFString_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFString_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFString_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFString_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSFString_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFString_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFString::setValue(SbString const &)\n"
    "    SoSFString::setValue(char const *)\n"
    "    SoSFString::setValue(SoSFString const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFString, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFString_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFColor", 0, 0, 0)) SWIG_fail;
  result = (SoSFColor *)new SoSFColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFColor" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFColor::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFColor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_getTypeId" "', argument " "1"" of type '" "SoSFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  result = ((SoSFColor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_copyFrom" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_isSame" "', argument " "1"" of type '" "SoSFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFColor const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_getValue" "', argument " "1"" of type '" "SoSFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  result = (SbColor *) &((SoSFColor const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setValue((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor___eq__" "', argument " "1"" of type '" "SoSFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor___eq__" "', argument " "2"" of type '" "SoSFColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor___eq__" "', argument " "2"" of type '" "SoSFColor const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  result = (int)((SoSFColor const *)arg1)->operator ==((SoSFColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFColor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor___ne__" "', argument " "1"" of type '" "SoSFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor___ne__" "', argument " "2"" of type '" "SoSFColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor___ne__" "', argument " "2"" of type '" "SoSFColor const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  result = (int)((SoSFColor const *)arg1)->operator !=((SoSFColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFColor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColor_initClass", 0, 0, 0)) SWIG_fail;
  SoSFColor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFColor_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFColor_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setHSVValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFColor_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFColor_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFColor_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setHSVValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setHSVValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFColor_setHSVValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFColor_setHSVValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFColor_setHSVValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFColor_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFColor::setHSVValue(float,float,float)\n"
    "    SoSFColor::setHSVValue(float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColor *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColor_setValue" "', argument " "1"" of type '" "SoSFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColor_setValue" "', argument " "2"" of type '" "SoSFColor const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  SoSFColor_setValue__SWIG_4(arg1,(SoSFColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColor_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFColor_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColor_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColor_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFColor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColor_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFColor_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFColor_setValue__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFColor_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFColor::setValue(SbColor const &)\n"
    "    SoSFColor::setValue(SbVec3f const &)\n"
    "    SoSFColor::setValue(float,float,float)\n"
    "    SoSFColor::setValue(float const [3])\n"
    "    SoSFColor::setValue(SoSFColor const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoReplacedElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoReplacedElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoReplacedElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_initClass", 0, 0, 0)) SWIG_fail;
  SoReplacedElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReplacedElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReplacedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReplacedElement_init" "', argument " "1"" of type '" "SoReplacedElement *""'"); 
  }
  arg1 = reinterpret_cast< SoReplacedElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReplacedElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReplacedElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReplacedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReplacedElement_matches" "', argument " "1"" of type '" "SoReplacedElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoReplacedElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReplacedElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoReplacedElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReplacedElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReplacedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReplacedElement_copyMatchInfo" "', argument " "1"" of type '" "SoReplacedElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoReplacedElement * >(argp1);
  result = (SoElement *)((SoReplacedElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_getNodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReplacedElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReplacedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReplacedElement_getNodeId" "', argument " "1"" of type '" "SoReplacedElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoReplacedElement * >(argp1);
  result = (SbUniqueId)((SoReplacedElement const *)arg1)->getNodeId();
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReplacedElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReplacedElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReplacedElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReplacedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReplacedElement_output" "', argument " "1"" of type '" "SoReplacedElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoReplacedElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoReplacedElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoReplacedElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoReplacedElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec3s *)new SbVec3s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short *arg1 = (short *)0 ;
  short temp1[3] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec3s_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec3s *)new SbVec3s((short const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short arg3 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec3s" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec3s" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  result = (SbVec3s *)new SbVec3s(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3us,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3us const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3us const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3us * >(argp1);
  result = (SbVec3s *)new SbVec3s((SbVec3us const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = (SbVec3s *)new SbVec3s((SbVec3b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = (SbVec3s *)new SbVec3s((SbVec3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (SbVec3s *)new SbVec3s((SbVec3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3s" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (SbVec3s *)new SbVec3s((SbVec3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3s(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec3s", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec3s__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3us, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec3s__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbVec3s__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec3s'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3s::SbVec3s()\n"
    "    SbVec3s::SbVec3s(short const [3])\n"
    "    SbVec3s::SbVec3s(short,short,short)\n"
    "    SbVec3s::SbVec3s(SbVec3us const &)\n"
    "    SbVec3s::SbVec3s(SbVec3b const &)\n"
    "    SbVec3s::SbVec3s(SbVec3i32 const &)\n"
    "    SbVec3s::SbVec3s(SbVec3f const &)\n"
    "    SbVec3s::SbVec3s(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short temp2[3] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  {
    convert_SbVec3s_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec3s *) &(arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec3s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  result = (SbVec3s *) &(arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3us * >(argp2);
  result = (SbVec3s *) &(arg1)->setValue((SbVec3us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3b * >(argp2);
  result = (SbVec3s *) &(arg1)->setValue((SbVec3b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3s *) &(arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3s *) &(arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_setValue" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3s *) &(arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3s_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec3s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbVec3s_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3s::setValue(short const [3])\n"
    "    SbVec3s::setValue(short,short,short)\n"
    "    SbVec3s::setValue(SbVec3us const &)\n"
    "    SbVec3s::setValue(SbVec3b const &)\n"
    "    SbVec3s::setValue(SbVec3i32 const &)\n"
    "    SbVec3s::setValue(SbVec3f const &)\n"
    "    SbVec3s::setValue(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3s_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_getValue" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = (short *)((SbVec3s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short temp2 ;
  int res2 = SWIG_TMPOBJ ;
  short temp3 ;
  int res3 = SWIG_TMPOBJ ;
  short temp4 ;
  int res4 = SWIG_TMPOBJ ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_getValue" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ((SbVec3s const *)arg1)->getValue(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_short, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_short, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_short, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3s_getValue", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec3s_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec3s_getValue__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3s_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3s::getValue() const\n"
    "    SbVec3s::getValue(short &,short &,short &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3s_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_dot" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s_dot" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s_dot" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (int32_t)((SbVec3s const *)arg1)->dot((SbVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_negate" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___imul__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___imul__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3s___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3s___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3s___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3s___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3s::operator *=(int)\n"
    "    SbVec3s::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3s___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___itruediv__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___itruediv__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3s___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3s___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3s___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3s___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3s::operator /=(int)\n"
    "    SbVec3s::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3s___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___iadd__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___iadd__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___iadd__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3s *) &(arg1)->operator +=((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___isub__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___isub__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___isub__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3s *) &(arg1)->operator -=((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___neg__" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = ((SbVec3s const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_toString" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = ((SbVec3s const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_fromString" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s_output" "', argument " "1"" of type '" "SbVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec3s const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___add__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___add__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___add__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = SbVec3s___add__(arg1,(SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___sub__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___sub__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___sub__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = SbVec3s___sub__(arg1,(SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___mul__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3s___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___rmul__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3s___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___div__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3s___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___truediv__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___truediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3s___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___eq__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___eq__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___eq__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (int)SbVec3s___eq__(arg1,(SbVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3s___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___nq__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3s___nq__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3s___nq__" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (int)SbVec3s___nq__(arg1,(SbVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___getitem__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (short)SbVec3s___getitem__(arg1,arg2);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3s___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3s___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3s___setitem__" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3s___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3s___setitem__" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  SbVec3s___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3s" "', argument " "1"" of type '" "SbVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMultiTextureImageElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoMultiTextureImageElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMultiTextureImageElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_initClass", 0, 0, 0)) SWIG_fail;
  SoMultiTextureImageElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_init" "', argument " "1"" of type '" "SoMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_setDefault" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_setDefault" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureImageElement_setDefault" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureImageElement::setDefault(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_setDefault" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_setDefault" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureImageElement::setDefault(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_setDefault", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureImageElement_setDefault__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureImageElement_setDefault__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_setDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::setDefault(SoState *const,SoNode *const,int const)\n"
    "    SoMultiTextureImageElement::setDefault(SoState *const,SoNode *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SbVec2s *arg4 = 0 ;
  int arg5 ;
  unsigned char *arg6 = 0 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Wrap arg8 ;
  SoMultiTextureImageElement::Model arg9 ;
  SbColor *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "SbVec2s const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2s * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "unsigned char const *""'"); 
  }
  arg6 = reinterpret_cast< unsigned char * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Wrap >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg9 = static_cast< SoMultiTextureImageElement::Model >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  SoMultiTextureImageElement::set(arg1,arg2,arg3,(SbVec2s const &)*arg4,arg5,(unsigned char const *)arg6,arg7,arg8,arg9,(SbColor const &)*arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SbVec3s *arg4 = 0 ;
  int arg5 ;
  unsigned char *arg6 = 0 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Wrap arg8 ;
  SoMultiTextureImageElement::Wrap arg9 ;
  SoMultiTextureImageElement::Model arg10 ;
  SbColor *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "SbVec3s const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3s * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "unsigned char const *""'"); 
  }
  arg6 = reinterpret_cast< unsigned char * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Wrap >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg9 = static_cast< SoMultiTextureImageElement::Wrap >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg10 = static_cast< SoMultiTextureImageElement::Model >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SoMultiTextureImageElement_set" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  arg11 = reinterpret_cast< SbColor * >(argp11);
  SoMultiTextureImageElement::set(arg1,arg2,arg3,(SbVec3s const &)*arg4,arg5,(unsigned char const *)arg6,arg7,arg8,arg9,arg10,(SbColor const &)*arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  SbVec2s *arg3 = 0 ;
  int *arg4 = 0 ;
  SoMultiTextureImageElement::Wrap *arg5 = 0 ;
  SoMultiTextureImageElement::Wrap *arg6 = 0 ;
  SoMultiTextureImageElement::Model *arg7 = 0 ;
  SbColor *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg5 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg6 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg7 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  arg8 = reinterpret_cast< SbColor * >(argp8);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  SbVec3s *arg3 = 0 ;
  int *arg4 = 0 ;
  SoMultiTextureImageElement::Wrap *arg5 = 0 ;
  SoMultiTextureImageElement::Wrap *arg6 = 0 ;
  SoMultiTextureImageElement::Wrap *arg7 = 0 ;
  SoMultiTextureImageElement::Model *arg8 = 0 ;
  SbColor *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg5 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg6 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg7 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg8 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoMultiTextureImageElement_get" "', argument " "9"" of type '" "SbColor &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "9"" of type '" "SbColor &""'"); 
  }
  arg9 = reinterpret_cast< SbColor * >(argp9);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  SbVec2s *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  result = (unsigned char *)SoMultiTextureImageElement::getImage(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  SbVec3s *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  result = (unsigned char *)SoMultiTextureImageElement::getImage(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getBlendColor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getBlendColor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getBlendColor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &SoMultiTextureImageElement::getBlendColor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getBlendColor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbColor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getBlendColor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoMultiTextureImageElement::getBlendColor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getBlendColor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getBlendColor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_getBlendColor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getBlendColor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getBlendColor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getBlendColor(SoState *const,int const)\n"
    "    SoMultiTextureImageElement::getBlendColor(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getModel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureImageElement::Model result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getModel" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getModel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureImageElement::Model)SoMultiTextureImageElement::getModel(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getModel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureImageElement::Model result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getModel" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureImageElement::Model)SoMultiTextureImageElement::getModel(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getModel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_getModel__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getModel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getModel(SoState *const,int const)\n"
    "    SoMultiTextureImageElement::getModel(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapS" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getWrapS" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapS(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapS" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapS(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getWrapS", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_getWrapS__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getWrapS__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getWrapS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getWrapS(SoState *const,int const)\n"
    "    SoMultiTextureImageElement::getWrapS(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapT" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getWrapT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapT(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapT" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapT(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getWrapT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_getWrapT__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getWrapT__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getWrapT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getWrapT(SoState *const,int const)\n"
    "    SoMultiTextureImageElement::getWrapT(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapR__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapR" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_getWrapR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapR(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapR__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureImageElement::Wrap result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getWrapR" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureImageElement::Wrap)SoMultiTextureImageElement::getWrapR(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getWrapR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getWrapR", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_getWrapR__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getWrapR__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getWrapR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getWrapR(SoState *const,int const)\n"
    "    SoMultiTextureImageElement::getWrapR(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_containsTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_containsTransparency" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoMultiTextureImageElement::containsTransparency(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "1"" of type '" "SbVec2s &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "1"" of type '" "SbVec2s &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (unsigned char *)SoMultiTextureImageElement::getDefault(*arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "1"" of type '" "SbVec3s &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "1"" of type '" "SbVec3s &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getDefault" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (unsigned char *)SoMultiTextureImageElement::getDefault(*arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getDefault", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getDefault__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureImageElement_getDefault__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getDefault(SbVec2s &,int &)\n"
    "    SoMultiTextureImageElement::getDefault(SbVec3s &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_push" "', argument " "1"" of type '" "SoMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_matches" "', argument " "1"" of type '" "SoMultiTextureImageElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoMultiTextureImageElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_copyMatchInfo" "', argument " "1"" of type '" "SoMultiTextureImageElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  result = (SoElement *)((SoMultiTextureImageElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setElt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  int arg2 ;
  SbUniqueId arg3 ;
  SbVec2s *arg4 = 0 ;
  int arg5 ;
  unsigned char *arg6 = 0 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Wrap arg8 ;
  SoMultiTextureImageElement::Model arg9 ;
  SbColor *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "1"" of type '" "SoMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "3"" of type '" "SbUniqueId""'");
  } 
  arg3 = static_cast< SbUniqueId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "4"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_setElt" "', argument " "4"" of type '" "SbVec2s const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2s * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "6"" of type '" "unsigned char const *""'"); 
  }
  arg6 = reinterpret_cast< unsigned char * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "8"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Wrap >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "9"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg9 = static_cast< SoMultiTextureImageElement::Model >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_setElt" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  (arg1)->setElt(arg2,arg3,(SbVec2s const &)*arg4,arg5,(unsigned char const *)arg6,arg7,arg8,arg9,(SbColor const &)*arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setElt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  int arg2 ;
  SbUniqueId arg3 ;
  SbVec3s *arg4 = 0 ;
  int arg5 ;
  unsigned char *arg6 = 0 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Wrap arg8 ;
  SoMultiTextureImageElement::Wrap arg9 ;
  SoMultiTextureImageElement::Model arg10 ;
  SbColor *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "1"" of type '" "SoMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "3"" of type '" "SbUniqueId""'");
  } 
  arg3 = static_cast< SbUniqueId >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "4"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_setElt" "', argument " "4"" of type '" "SbVec3s const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3s * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "6"" of type '" "unsigned char const *""'"); 
  }
  arg6 = reinterpret_cast< unsigned char * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "8"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Wrap >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "9"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg9 = static_cast< SoMultiTextureImageElement::Wrap >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "10"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg10 = static_cast< SoMultiTextureImageElement::Model >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SoMultiTextureImageElement_setElt" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_setElt" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  arg11 = reinterpret_cast< SbColor * >(argp11);
  (arg1)->setElt(arg2,arg3,(SbVec3s const &)*arg4,arg5,(unsigned char const *)arg6,arg7,arg8,arg9,arg10,(SbColor const &)*arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_setElt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_setElt", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureImageElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_unsigned_char, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SoMultiTextureImageElement_setElt__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureImageElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_unsigned_char, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_SoMultiTextureImageElement_setElt__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_setElt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::setElt(int const,SbUniqueId const,SbVec2s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n"
    "    SoMultiTextureImageElement::setElt(int const,SbUniqueId const,SbVec3s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_hasTransparency__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_hasTransparency" "', argument " "1"" of type '" "SoMultiTextureImageElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureImageElement_hasTransparency" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoMultiTextureImageElement const *)arg1)->hasTransparency(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_hasTransparency__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureImageElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_hasTransparency" "', argument " "1"" of type '" "SoMultiTextureImageElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureImageElement * >(argp1);
  result = (SbBool)((SoMultiTextureImageElement const *)arg1)->hasTransparency();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_hasTransparency(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_hasTransparency", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureImageElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureImageElement_hasTransparency__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureImageElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureImageElement_hasTransparency__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_hasTransparency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::hasTransparency(int const) const\n"
    "    SoMultiTextureImageElement::hasTransparency() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  unsigned char *arg5 = 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SbColor *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "unsigned char const *""'"); 
  }
  arg5 = reinterpret_cast< unsigned char * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  arg9 = reinterpret_cast< SbColor * >(argp9);
  SoMultiTextureImageElement::set(arg1,arg2,(SbVec2s const &)*arg3,arg4,(unsigned char const *)arg5,arg6,arg7,arg8,(SbColor const &)*arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  unsigned char *arg5 = 0 ;
  SoMultiTextureImageElement::Wrap arg6 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Model arg8 ;
  SbColor *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "unsigned char const *""'"); 
  }
  arg5 = reinterpret_cast< unsigned char * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg6 = static_cast< SoMultiTextureImageElement::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Model >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  arg9 = reinterpret_cast< SbColor * >(argp9);
  SoMultiTextureImageElement::set(arg1,arg2,(SbVec2s const &)*arg3,arg4,(unsigned char const *)arg5,arg6,arg7,arg8,(SbColor const &)*arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  unsigned char *arg5 = 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  SbColor *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "unsigned char const *""'"); 
  }
  arg5 = reinterpret_cast< unsigned char * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  SoMultiTextureImageElement::set(arg1,arg2,(SbVec3s const &)*arg3,arg4,(unsigned char const *)arg5,arg6,arg7,arg8,arg9,(SbColor const &)*arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  unsigned char *arg5 = 0 ;
  SoMultiTextureImageElement::Wrap arg6 ;
  SoMultiTextureImageElement::Wrap arg7 ;
  SoMultiTextureImageElement::Wrap arg8 ;
  SoMultiTextureImageElement::Model arg9 ;
  SbColor *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureImageElement_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_set" "', argument " "5"" of type '" "unsigned char const *""'"); 
  }
  arg5 = reinterpret_cast< unsigned char * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMultiTextureImageElement_set" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg6 = static_cast< SoMultiTextureImageElement::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMultiTextureImageElement_set" "', argument " "7"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg7 = static_cast< SoMultiTextureImageElement::Wrap >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMultiTextureImageElement_set" "', argument " "8"" of type '" "SoMultiTextureImageElement::Wrap""'");
  } 
  arg8 = static_cast< SoMultiTextureImageElement::Wrap >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMultiTextureImageElement_set" "', argument " "9"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg9 = static_cast< SoMultiTextureImageElement::Model >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_set" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  SoMultiTextureImageElement::set(arg1,arg2,(SbVec3s const &)*arg3,arg4,(unsigned char const *)arg5,arg6,arg7,arg8,arg9,(SbColor const &)*arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_set", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_SoMultiTextureImageElement_set__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_SoMultiTextureImageElement_set__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SoMultiTextureImageElement_set__SWIG_4(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SoMultiTextureImageElement_set__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_unsigned_char, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SoMultiTextureImageElement_set__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_unsigned_char, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_SoMultiTextureImageElement_set__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,int const,SbVec2s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,int const,SbVec3s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,SbVec2s const &,int const,unsigned char const *,int const,int const,int const,SbColor const &)\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,SbVec2s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,SbVec3s const &,int const,unsigned char const *,int const,int const,int const,int const,SbColor const &)\n"
    "    SoMultiTextureImageElement::set(SoState *const,SoNode *const,SbVec3s const &,int const,unsigned char const *,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Wrap const,SoMultiTextureImageElement::Model const,SbColor const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  SoMultiTextureImageElement::Wrap *arg4 = 0 ;
  SoMultiTextureImageElement::Wrap *arg5 = 0 ;
  SoMultiTextureImageElement::Model *arg6 = 0 ;
  SbColor *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg4 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg5 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg6 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SbColor &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SbColor &""'"); 
  }
  arg7 = reinterpret_cast< SbColor * >(argp7);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  SoMultiTextureImageElement::Wrap *arg4 = 0 ;
  SoMultiTextureImageElement::Wrap *arg5 = 0 ;
  SoMultiTextureImageElement::Wrap *arg6 = 0 ;
  SoMultiTextureImageElement::Model *arg7 = 0 ;
  SbColor *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg4 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg5 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SoMultiTextureImageElement__Wrap,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "SoMultiTextureImageElement::Wrap &""'"); 
  }
  arg6 = reinterpret_cast< SoMultiTextureImageElement::Wrap * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg7 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  arg8 = reinterpret_cast< SbColor * >(argp8);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  int *arg6 = 0 ;
  SbColor *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SbColor &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "SbColor &""'"); 
  }
  arg7 = reinterpret_cast< SbColor * >(argp7);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  SbColor *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "int &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "6"" of type '" "int &""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "int &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "7"" of type '" "int &""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_get" "', argument " "8"" of type '" "SbColor &""'"); 
  }
  arg8 = reinterpret_cast< SbColor * >(argp8);
  result = (unsigned char *)SoMultiTextureImageElement::get(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_get", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoMultiTextureImageElement_get__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoMultiTextureImageElement_get__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SoMultiTextureImageElement_get__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SoMultiTextureImageElement_get__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SoMultiTextureImageElement_get__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Wrap, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_SoMultiTextureImageElement_get__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::get(SoState *const,int const,SbVec2s &,int &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Model &,SbColor &)\n"
    "    SoMultiTextureImageElement::get(SoState *const,int const,SbVec3s &,int &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Model &,SbColor &)\n"
    "    SoMultiTextureImageElement::get(SoState *const,SbVec2s &,int &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Model &,SbColor &)\n"
    "    SoMultiTextureImageElement::get(SoState *const,SbVec3s &,int &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Wrap &,SoMultiTextureImageElement::Model &,SbColor &)\n"
    "    SoMultiTextureImageElement::get(SoState *const,SbVec2s &,int &,int &,int &,int &,SbColor &)\n"
    "    SoMultiTextureImageElement::get(SoState *const,SbVec3s &,int &,int &,int &,int &,int &,SbColor &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getImage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)SoMultiTextureImageElement::getImage(arg1,*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getImage__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureImageElement_getImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)SoMultiTextureImageElement::getImage(arg1,*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureImageElement_getImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureImageElement_getImage", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMultiTextureImageElement_getImage__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMultiTextureImageElement_getImage__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureImageElement_getImage__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureImageElement_getImage__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureImageElement_getImage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureImageElement::getImage(SoState *const,int const,SbVec2s &,int &)\n"
    "    SoMultiTextureImageElement::getImage(SoState *const,int const,SbVec3s &,int &)\n"
    "    SoMultiTextureImageElement::getImage(SoState *const,SbVec2s &,int &)\n"
    "    SoMultiTextureImageElement::getImage(SoState *const,SbVec3s &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMultiTextureImageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMultiTextureImageElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTexture2_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture2::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_getTypeId" "', argument " "1"" of type '" "SoTexture2 const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = ((SoTexture2 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture2::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTexture2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTexture2", 0, 0, 0)) SWIG_fail;
  result = (SoTexture2 *)new SoTexture2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTexture2, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_filename_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_filename_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->filename = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_filename_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFString *)& ((arg1)->filename);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_image_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_image_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->image = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_image_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFImage *)& ((arg1)->image);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_wrapS_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_wrapS_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_wrapT_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_wrapT_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_model_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_model_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_blendColor_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_blendColor_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_enableCompressedTexture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_enableCompressedTexture_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_enableCompressedTexture_set" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_enableCompressedTexture_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enableCompressedTexture = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_enableCompressedTexture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_enableCompressedTexture_get" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  result = (SoSFBool *)& ((arg1)->enableCompressedTexture);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_doAction" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_GLRender" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_callback" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2 *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2_rayPick" "', argument " "1"" of type '" "SoTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2_readImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  unsigned char **arg5 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2_readImage", 5, 5, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2_readImage" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTexture2_readImage" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTexture2_readImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTexture2_readImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTexture2_readImage" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTexture2_readImage" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoTexture2_readImage" "', argument " "5"" of type '" "unsigned char *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTexture2_readImage" "', argument " "5"" of type '" "unsigned char *&""'"); 
  }
  arg5 = reinterpret_cast< unsigned char ** >(argp5);
  result = (SbBool)SoTexture2::readImage((SbString const &)*arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoTexture2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTexture2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateBindingElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextureCoordinateBindingElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextureCoordinateBindingElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateBindingElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBindingElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBindingElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBindingElement_init" "', argument " "1"" of type '" "SoTextureCoordinateBindingElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBindingElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBindingElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoTextureCoordinateBindingElement::Binding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBindingElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextureCoordinateBindingElement_set" "', argument " "3"" of type '" "SoTextureCoordinateBindingElement::Binding""'");
  } 
  arg3 = static_cast< SoTextureCoordinateBindingElement::Binding >(val3);
  SoTextureCoordinateBindingElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoTextureCoordinateBindingElement::Binding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCoordinateBindingElement_set" "', argument " "2"" of type '" "SoTextureCoordinateBindingElement::Binding""'");
  } 
  arg2 = static_cast< SoTextureCoordinateBindingElement::Binding >(val2);
  SoTextureCoordinateBindingElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoTextureCoordinateBindingElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoTextureCoordinateBindingElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTextureCoordinateBindingElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextureCoordinateBindingElement::set(SoState *const,SoNode *const,SoTextureCoordinateBindingElement::Binding const)\n"
    "    SoTextureCoordinateBindingElement::set(SoState *const,SoTextureCoordinateBindingElement::Binding const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTextureCoordinateBindingElement::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBindingElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoTextureCoordinateBindingElement::Binding)SoTextureCoordinateBindingElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBindingElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBindingElement::Binding result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBindingElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateBindingElement::Binding)SoTextureCoordinateBindingElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateBindingElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateBindingElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateBinding::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateBinding const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  result = ((SoTextureCoordinateBinding const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateBinding::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateBinding", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateBinding *)new SoTextureCoordinateBinding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateBinding, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_value_set" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBinding_value_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_value_get" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  result = (SoSFEnum *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_doAction" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBinding_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_callback" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBinding_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBinding_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBinding_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBinding *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBinding_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBinding_pick" "', argument " "1"" of type '" "SoTextureCoordinateBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBinding_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateBinding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateBinding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateBinding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformation_getTypeId" "', argument " "1"" of type '" "SoTransformation const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformation * >(argp1);
  result = ((SoTransformation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformation_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoUnits_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoUnits::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_getTypeId" "', argument " "1"" of type '" "SoUnits const *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  result = ((SoUnits const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_initClass", 0, 0, 0)) SWIG_fail;
  SoUnits::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoUnits", 0, 0, 0)) SWIG_fail;
  result = (SoUnits *)new SoUnits();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoUnits, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_units_set" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_units_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->units = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_units_get" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  result = (SoSFEnum *)& ((arg1)->units);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_doAction" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_callback" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_getBoundingBox" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_getMatrix" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_GLRender" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_pick" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnits_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnits *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnits_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnits_getPrimitiveCount" "', argument " "1"" of type '" "SoUnits *""'"); 
  }
  arg1 = reinterpret_cast< SoUnits * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnits_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoUnits_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoUnits, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoUnits_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCallbackAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTypeId" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = ((SoCallbackAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCallbackAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoCallbackAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoCallbackAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_initClass", 0, 0, 0)) SWIG_fail;
  SoCallbackAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCallbackAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoCallbackAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoCallbackAction *)new SoCallbackAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCallbackAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCallbackAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoCallbackAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoCallbackAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoCallbackAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoCallbackAction *)new SoCallbackAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCallbackAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCallbackAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoCallbackAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoCallbackAction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoCallbackAction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoCallbackAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::SoCallbackAction()\n"
    "    SoCallbackAction::SoCallbackAction(SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoCallbackAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoCallbackAction" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_setViewportRegion" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  SoCallbackAction::SoCallbackActionCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPreCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPreCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPreCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addPreCallback" "', argument " "3"" of type '" "SoCallbackAction::SoCallbackActionCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_addPreCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addPreCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  SoCallbackAction::SoCallbackActionCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPostCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPostCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPostCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addPostCallback" "', argument " "3"" of type '" "SoCallbackAction::SoCallbackActionCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_addPostCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addPostCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreTailCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoCallbackAction::SoCallbackActionCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPreTailCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addPreTailCallback" "', argument " "2"" of type '" "SoCallbackAction::SoCallbackActionCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_addPreTailCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addPreTailCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostTailCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoCallbackAction::SoCallbackActionCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPostTailCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addPostTailCallback" "', argument " "2"" of type '" "SoCallbackAction::SoCallbackActionCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_addPostTailCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addPostTailCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addTriangleCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  SoTriangleCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "3"" of type '" "SoTriangleCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addTriangleCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addLineSegmentCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  SoLineSegmentCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "3"" of type '" "SoLineSegmentCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addLineSegmentCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPointCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  SoPointCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPointCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPointCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPointCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackAction_addPointCallback" "', argument " "3"" of type '" "SoPointCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_addPointCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addPointCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getDecimationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDecimationTypeElement::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getDecimationType" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoDecimationTypeElement::Type)((SoCallbackAction const *)arg1)->getDecimationType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getDecimationPercentage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getDecimationPercentage" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getDecimationPercentage();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getComplexity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getComplexity" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getComplexity();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getComplexityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoComplexity::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getComplexityType" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoComplexity::Type)((SoCallbackAction const *)arg1)->getComplexityType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNumCoordinates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNumCoordinates" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (int32_t)((SoCallbackAction const *)arg1)->getNumCoordinates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getCoordinate3", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getCoordinate3" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getCoordinate3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoCallbackAction const *)arg1)->getCoordinate3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getCoordinate4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getCoordinate4", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getCoordinate4" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getCoordinate4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &((SoCallbackAction const *)arg1)->getCoordinate4(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getDrawStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDrawStyle::Style result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getDrawStyle" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoDrawStyle::Style)((SoCallbackAction const *)arg1)->getDrawStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getLinePattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getLinePattern" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (unsigned short)((SoCallbackAction const *)arg1)->getLinePattern();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getLineWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getLineWidth" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getLineWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getPointSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getPointSize" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getPointSize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getFontName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getFontName" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbName *) &((SoCallbackAction const *)arg1)->getFontName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getFontSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getFontSize" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getFontSize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoLightModel::Model result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getLightModel" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoLightModel::Model)((SoCallbackAction const *)arg1)->getLightModel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getLightAttenuation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getLightAttenuation" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbVec3f *) &((SoCallbackAction const *)arg1)->getLightAttenuation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getMaterialBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMaterialBinding::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getMaterialBinding" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoMaterialBinding::Binding)((SoCallbackAction const *)arg1)->getMaterialBinding();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNumNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNumNormals" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (uint32_t)((SoCallbackAction const *)arg1)->getNumNormals();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getNormal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNormal" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getNormal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoCallbackAction const *)arg1)->getNormal(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNormalBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNormalBinding::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNormalBinding" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoNormalBinding::Binding)((SoCallbackAction const *)arg1)->getNormalBinding();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNumProfileCoordinates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNumProfileCoordinates" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (int32_t)((SoCallbackAction const *)arg1)->getNumProfileCoordinates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getProfileCoordinate2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getProfileCoordinate2", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getProfileCoordinate2" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getProfileCoordinate2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &((SoCallbackAction const *)arg1)->getProfileCoordinate2(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getProfileCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getProfileCoordinate3", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getProfileCoordinate3" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getProfileCoordinate3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoCallbackAction const *)arg1)->getProfileCoordinate3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getProfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodeList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getProfile" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoNodeList *) &((SoCallbackAction const *)arg1)->getProfile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getVertexOrdering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHints::VertexOrdering result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getVertexOrdering" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoShapeHints::VertexOrdering)((SoCallbackAction const *)arg1)->getVertexOrdering();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getShapeType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHints::ShapeType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getShapeType" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoShapeHints::ShapeType)((SoCallbackAction const *)arg1)->getShapeType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getFaceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeHints::FaceType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getFaceType" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoShapeHints::FaceType)((SoCallbackAction const *)arg1)->getFaceType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getCreaseAngle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getCreaseAngle" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getCreaseAngle();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getNumTextureCoordinates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getNumTextureCoordinates" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (int32_t)((SoCallbackAction const *)arg1)->getNumTextureCoordinates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureCoordinate2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getTextureCoordinate2", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureCoordinate2" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getTextureCoordinate2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &((SoCallbackAction const *)arg1)->getTextureCoordinate2(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getTextureCoordinate3", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureCoordinate3" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getTextureCoordinate3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoCallbackAction const *)arg1)->getTextureCoordinate3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureCoordinate4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_getTextureCoordinate4", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureCoordinate4" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getTextureCoordinate4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &((SoCallbackAction const *)arg1)->getTextureCoordinate4(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureCoordinateBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTextureCoordinateBinding::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureCoordinateBinding" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoTextureCoordinateBinding::Binding)((SoCallbackAction const *)arg1)->getTextureCoordinateBinding();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureBlendColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureBlendColor" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbColor *) &((SoCallbackAction const *)arg1)->getTextureBlendColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureImage" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_getTextureImage" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_getTextureImage" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_getTextureImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_getTextureImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)((SoCallbackAction const *)arg1)->getTextureImage(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureImage" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_getTextureImage" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_getTextureImage" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_getTextureImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_getTextureImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)((SoCallbackAction const *)arg1)->getTextureImage(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_getTextureImage", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackAction_getTextureImage__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackAction_getTextureImage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_getTextureImage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::getTextureImage(SbVec2s &,int &) const\n"
    "    SoCallbackAction::getTextureImage(SbVec3s &,int &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureMatrix" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbMatrix *) &((SoCallbackAction const *)arg1)->getTextureMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTexture2::Model result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureModel" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoTexture2::Model)((SoCallbackAction const *)arg1)->getTextureModel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureWrapS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTexture2::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureWrapS" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoTexture2::Wrap)((SoCallbackAction const *)arg1)->getTextureWrapS();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureWrapT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTexture2::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureWrapT" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoTexture2::Wrap)((SoCallbackAction const *)arg1)->getTextureWrapT();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getTextureWrapR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTexture2::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getTextureWrapR" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoTexture2::Wrap)((SoCallbackAction const *)arg1)->getTextureWrapR();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getModelMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getModelMatrix" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbMatrix *) &((SoCallbackAction const *)arg1)->getModelMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoUnits::Units result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getUnits" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoUnits::Units)((SoCallbackAction const *)arg1)->getUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getFocalDistance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getFocalDistance" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (float)((SoCallbackAction const *)arg1)->getFocalDistance();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getProjectionMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getProjectionMatrix" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbMatrix *) &((SoCallbackAction const *)arg1)->getProjectionMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getViewingMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getViewingMatrix" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbMatrix *) &((SoCallbackAction const *)arg1)->getViewingMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getViewVolume" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbViewVolume *) &((SoCallbackAction const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getViewportRegion" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbViewportRegion *) &((SoCallbackAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getPickStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickStyle::Style result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getPickStyle" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoPickStyle::Style)((SoCallbackAction const *)arg1)->getPickStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getSwitch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getSwitch" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (int32_t)((SoCallbackAction const *)arg1)->getSwitch();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getCurrentResponse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCallbackAction::Response result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getCurrentResponse" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoCallbackAction::Response)((SoCallbackAction const *)arg1)->getCurrentResponse();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_invokePreCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_invokePreCallbacks", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_invokePreCallbacks" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_invokePreCallbacks" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->invokePreCallbacks((SoNode const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_invokePostCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_invokePostCallbacks", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_invokePostCallbacks" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_invokePostCallbacks" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->invokePostCallbacks((SoNode const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_invokeTriangleCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoShape *arg2 = (SoShape *)0 ;
  SoPrimitiveVertex *arg3 = (SoPrimitiveVertex *)0 ;
  SoPrimitiveVertex *arg4 = (SoPrimitiveVertex *)0 ;
  SoPrimitiveVertex *arg5 = (SoPrimitiveVertex *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_invokeTriangleCallbacks", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_invokeTriangleCallbacks" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_invokeTriangleCallbacks" "', argument " "2"" of type '" "SoShape const *const""'"); 
  }
  arg2 = reinterpret_cast< SoShape * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_invokeTriangleCallbacks" "', argument " "3"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_invokeTriangleCallbacks" "', argument " "4"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg4 = reinterpret_cast< SoPrimitiveVertex * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoCallbackAction_invokeTriangleCallbacks" "', argument " "5"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg5 = reinterpret_cast< SoPrimitiveVertex * >(argp5);
  (arg1)->invokeTriangleCallbacks((SoShape const *)arg2,(SoPrimitiveVertex const *)arg3,(SoPrimitiveVertex const *)arg4,(SoPrimitiveVertex const *)arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_invokeLineSegmentCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoShape *arg2 = (SoShape *)0 ;
  SoPrimitiveVertex *arg3 = (SoPrimitiveVertex *)0 ;
  SoPrimitiveVertex *arg4 = (SoPrimitiveVertex *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_invokeLineSegmentCallbacks", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_invokeLineSegmentCallbacks" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_invokeLineSegmentCallbacks" "', argument " "2"" of type '" "SoShape const *const""'"); 
  }
  arg2 = reinterpret_cast< SoShape * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_invokeLineSegmentCallbacks" "', argument " "3"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCallbackAction_invokeLineSegmentCallbacks" "', argument " "4"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg4 = reinterpret_cast< SoPrimitiveVertex * >(argp4);
  (arg1)->invokeLineSegmentCallbacks((SoShape const *)arg2,(SoPrimitiveVertex const *)arg3,(SoPrimitiveVertex const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_invokePointCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoShape *arg2 = (SoShape *)0 ;
  SoPrimitiveVertex *arg3 = (SoPrimitiveVertex *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_invokePointCallbacks", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_invokePointCallbacks" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_invokePointCallbacks" "', argument " "2"" of type '" "SoShape const *const""'"); 
  }
  arg2 = reinterpret_cast< SoShape * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackAction_invokePointCallbacks" "', argument " "3"" of type '" "SoPrimitiveVertex const *const""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  (arg1)->invokePointCallbacks((SoShape const *)arg2,(SoPrimitiveVertex const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_shouldGeneratePrimitives(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoShape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_shouldGeneratePrimitives", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_shouldGeneratePrimitives" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_shouldGeneratePrimitives" "', argument " "2"" of type '" "SoShape const *""'"); 
  }
  arg2 = reinterpret_cast< SoShape * >(argp2);
  result = (SbBool)((SoCallbackAction const *)arg1)->shouldGeneratePrimitives((SoShape const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getCurPathTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getCurPathTail" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SoNode *)(arg1)->getCurPathTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_setCurrentNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_setCurrentNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_setCurrentNode" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_setCurrentNode" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setCurrentNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_setCallbackAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackAction_setCallbackAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_setCallbackAll" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_setCallbackAll" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCallbackAll(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_isCallbackAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_isCallbackAll" "', argument " "1"" of type '" "SoCallbackAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (SbBool)((SoCallbackAction const *)arg1)->isCallbackAll();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getMaterial__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getMaterial" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCallbackAction_getMaterial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (PyObject *)SoCallbackAction_getMaterial__SWIG_0(arg1,arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getMaterial__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_getMaterial" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  result = (PyObject *)SoCallbackAction_getMaterial__SWIG_0(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_getMaterial(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_getMaterial", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoCallbackAction_getMaterial__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoCallbackAction_getMaterial__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_getMaterial'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::getMaterial(int const)\n"
    "    SoCallbackAction::getMaterial()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPreCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPreCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPreCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoCallbackAction_addPreCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addPreCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCallbackAction_addPreCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoCallbackAction_addPreCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addPreCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addPreCallback(SoType const,SoCallbackAction::SoCallbackActionCB *,void *)\n"
    "    SoCallbackAction::addPreCallback(SoType const,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPostCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPostCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPostCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoCallbackAction_addPostCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addPostCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCallbackAction_addPostCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoCallbackAction_addPostCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addPostCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addPostCallback(SoType const,SoCallbackAction::SoCallbackActionCB *,void *)\n"
    "    SoCallbackAction::addPostCallback(SoType const,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreTailCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPreTailCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoCallbackAction_addPreTailCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPreTailCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addPreTailCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackAction_addPreTailCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoCallbackAction_addPreTailCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addPreTailCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addPreTailCallback(SoCallbackAction::SoCallbackActionCB *,void *)\n"
    "    SoCallbackAction::addPreTailCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostTailCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPostTailCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoCallbackAction_addPostTailCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPostTailCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addPostTailCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackAction_addPostTailCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoCallbackAction_addPostTailCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addPostTailCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addPostTailCallback(SoCallbackAction::SoCallbackActionCB *,void *)\n"
    "    SoCallbackAction::addPostTailCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addTriangleCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addTriangleCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoCallbackAction_addTriangleCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addTriangleCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addTriangleCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCallbackAction_addTriangleCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoCallbackAction_addTriangleCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addTriangleCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addTriangleCallback(SoType const,SoTriangleCB *,void *)\n"
    "    SoCallbackAction::addTriangleCallback(SoType const,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addLineSegmentCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addLineSegmentCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoCallbackAction_addLineSegmentCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addLineSegmentCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addLineSegmentCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCallbackAction_addLineSegmentCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoCallbackAction_addLineSegmentCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addLineSegmentCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addLineSegmentCallback(SoType const,SoLineSegmentCB *,void *)\n"
    "    SoCallbackAction::addLineSegmentCallback(SoType const,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPointCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackAction_addPointCallback" "', argument " "1"" of type '" "SoCallbackAction *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackAction_addPointCallback" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCallbackAction_addPointCallback" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoCallbackAction_addPointCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackAction_addPointCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackAction_addPointCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCallbackAction_addPointCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoCallbackAction_addPointCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackAction_addPointCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackAction::addPointCallback(SoType const,SoPointCB *,void *)\n"
    "    SoCallbackAction::addPointCallback(SoType const,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoCallbackAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCallbackAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCallbackAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbViewportRegion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbViewportRegion *)new SbViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbViewportRegion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbViewportRegion" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbViewportRegion" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  result = (SbViewportRegion *)new SbViewportRegion(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbViewportRegion__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbViewportRegion" "', argument " "1"" of type '" "SbVec2s""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbViewportRegion" "', argument " "1"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (SbViewportRegion *)new SbViewportRegion(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbViewportRegion__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbViewportRegion" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbViewportRegion" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbViewportRegion *)new SbViewportRegion((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbViewportRegion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbViewportRegion", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbViewportRegion__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbViewportRegion__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbViewportRegion__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbViewportRegion__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbViewportRegion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewportRegion::SbViewportRegion()\n"
    "    SbViewportRegion::SbViewportRegion(short,short)\n"
    "    SbViewportRegion::SbViewportRegion(SbVec2s)\n"
    "    SbViewportRegion::SbViewportRegion(SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setWindowSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setWindowSize" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_setWindowSize" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewportRegion_setWindowSize" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  (arg1)->setWindowSize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setWindowSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setWindowSize" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewportRegion_setWindowSize" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion_setWindowSize" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setWindowSize(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setWindowSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewportRegion_setWindowSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbViewportRegion_setWindowSize__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbViewportRegion_setWindowSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewportRegion_setWindowSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewportRegion::setWindowSize(short,short)\n"
    "    SbViewportRegion::setWindowSize(SbVec2s)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewport__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setViewport" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_setViewport" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewportRegion_setViewport" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewportRegion_setViewport" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewportRegion_setViewport" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setViewport(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewport__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  SbVec2f arg2 ;
  SbVec2f arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setViewport" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewportRegion_setViewport" "', argument " "2"" of type '" "SbVec2f""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion_setViewport" "', argument " "2"" of type '" "SbVec2f""'");
    } else {
      SbVec2f * temp = reinterpret_cast< SbVec2f * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewportRegion_setViewport" "', argument " "3"" of type '" "SbVec2f""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion_setViewport" "', argument " "3"" of type '" "SbVec2f""'");
    } else {
      SbVec2f * temp = reinterpret_cast< SbVec2f * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setViewport(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewport(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewportRegion_setViewport", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbViewportRegion_setViewport__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbViewportRegion_setViewport__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewportRegion_setViewport'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewportRegion::setViewport(float,float,float,float)\n"
    "    SbViewportRegion::setViewport(SbVec2f,SbVec2f)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewportPixels__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  (arg1)->setViewportPixels(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewportPixels__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  SbVec2s arg2 ;
  SbVec2s arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion_setViewportPixels" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewportRegion_setViewportPixels" "', argument " "3"" of type '" "SbVec2s""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion_setViewportPixels" "', argument " "3"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setViewportPixels(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setViewportPixels(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewportRegion_setViewportPixels", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbViewportRegion_setViewportPixels__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewportRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbViewportRegion_setViewportPixels__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewportRegion_setViewportPixels'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewportRegion::setViewportPixels(short,short,short,short)\n"
    "    SbViewportRegion::setViewportPixels(SbVec2s,SbVec2s)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getWindowSize" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbVec2s *) &((SbViewportRegion const *)arg1)->getWindowSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getViewportOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getViewportOrigin" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbVec2f *) &((SbViewportRegion const *)arg1)->getViewportOrigin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getViewportOriginPixels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getViewportOriginPixels" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbVec2s *) &((SbViewportRegion const *)arg1)->getViewportOriginPixels();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getViewportSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getViewportSize" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbVec2f *) &((SbViewportRegion const *)arg1)->getViewportSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getViewportSizePixels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getViewportSizePixels" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SbVec2s *) &((SbViewportRegion const *)arg1)->getViewportSizePixels();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getViewportAspectRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getViewportAspectRatio" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (float)((SbViewportRegion const *)arg1)->getViewportAspectRatio();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_scaleWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion_scaleWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_scaleWidth" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_scaleWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_scaleHeight" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_setPixelsPerInch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion_setPixelsPerInch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_setPixelsPerInch" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewportRegion_setPixelsPerInch" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setPixelsPerInch(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getPixelsPerInch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getPixelsPerInch" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (float)((SbViewportRegion const *)arg1)->getPixelsPerInch();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_getPixelsPerPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_getPixelsPerPoint" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (float)((SbViewportRegion const *)arg1)->getPixelsPerPoint();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion_output" "', argument " "1"" of type '" "SbViewportRegion const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbViewportRegion const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion___eq__" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewportRegion___eq__" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion___eq__" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  result = (int)SbViewportRegion___eq__(arg1,(SbViewportRegion const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbViewportRegion___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewportRegion___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewportRegion___ne__" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewportRegion___ne__" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewportRegion___ne__" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  result = (int)SbViewportRegion___ne__(arg1,(SbViewportRegion const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbViewportRegion" "', argument " "1"" of type '" "SbViewportRegion *""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbViewportRegion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbViewportRegion, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbViewportRegion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGLRenderAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getTypeId" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = ((SoGLRenderAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLRenderAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoGLRenderAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGLRenderAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_initClass", 0, 0, 0)) SWIG_fail;
  SoGLRenderAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGLRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoGLRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoGLRenderAction *)new SoGLRenderAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGLRenderAction" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setViewportRegion" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getViewportRegion" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbViewportRegion *) &((SoGLRenderAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setUpdateArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setUpdateArea", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setUpdateArea" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderAction_setUpdateArea" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_setUpdateArea" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_setUpdateArea" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_setUpdateArea" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->setUpdateArea((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getUpdateArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_getUpdateArea", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getUpdateArea" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderAction_getUpdateArea" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_getUpdateArea" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_getUpdateArea" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_getUpdateArea" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  ((SoGLRenderAction const *)arg1)->getUpdateArea(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setAbortCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::SoGLRenderAbortCB *arg2 = (SoGLRenderAction::SoGLRenderAbortCB *)0 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setAbortCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__SoGLRenderAction__AbortCode);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_setAbortCallback" "', argument " "2"" of type '" "SoGLRenderAction::SoGLRenderAbortCB *const""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_setAbortCallback" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setAbortCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getAbortCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::SoGLRenderAbortCB **arg2 = 0 ;
  void **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_getAbortCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getAbortCallback" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_f_p_void__SoGLRenderAction__AbortCode,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderAction_getAbortCallback" "', argument " "2"" of type '" "SoGLRenderAction::SoGLRenderAbortCB *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_getAbortCallback" "', argument " "2"" of type '" "SoGLRenderAction::SoGLRenderAbortCB *&""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction::SoGLRenderAbortCB ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_getAbortCallback" "', argument " "3"" of type '" "void *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLRenderAction_getAbortCallback" "', argument " "3"" of type '" "void *&""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);
  ((SoGLRenderAction const *)arg1)->getAbortCallback(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::TransparencyType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setTransparencyType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setTransparencyType" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setTransparencyType" "', argument " "2"" of type '" "SoGLRenderAction::TransparencyType""'");
  } 
  arg2 = static_cast< SoGLRenderAction::TransparencyType >(val2);
  (arg1)->setTransparencyType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction::TransparencyType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getTransparencyType" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SoGLRenderAction::TransparencyType)((SoGLRenderAction const *)arg1)->getTransparencyType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setTransparentDelayedObjectRenderType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::TransparentDelayedObjectRenderType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setTransparentDelayedObjectRenderType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setTransparentDelayedObjectRenderType" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setTransparentDelayedObjectRenderType" "', argument " "2"" of type '" "SoGLRenderAction::TransparentDelayedObjectRenderType""'");
  } 
  arg2 = static_cast< SoGLRenderAction::TransparentDelayedObjectRenderType >(val2);
  (arg1)->setTransparentDelayedObjectRenderType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getTransparentDelayedObjectRenderType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction::TransparentDelayedObjectRenderType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getTransparentDelayedObjectRenderType" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SoGLRenderAction::TransparentDelayedObjectRenderType)((SoGLRenderAction const *)arg1)->getTransparentDelayedObjectRenderType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSmoothing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setSmoothing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setSmoothing" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setSmoothing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setSmoothing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_isSmoothing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_isSmoothing" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->isSmoothing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setNumPasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setNumPasses", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setNumPasses" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setNumPasses" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNumPasses(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getNumPasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getNumPasses" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (int)((SoGLRenderAction const *)arg1)->getNumPasses();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setPassUpdate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setPassUpdate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setPassUpdate" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setPassUpdate" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setPassUpdate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_isPassUpdate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_isPassUpdate" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->isPassUpdate();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setPassCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderPassCB *arg2 = (SoGLRenderPassCB *)0 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setPassCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_setPassCallback" "', argument " "2"" of type '" "SoGLRenderPassCB *const""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_setPassCallback" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setPassCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setCacheContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setCacheContext", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setCacheContext" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setCacheContext" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setCacheContext(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getCacheContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getCacheContext" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (uint32_t)((SoGLRenderAction const *)arg1)->getCacheContext();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_addDelayedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_addDelayedPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_addDelayedPath" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderAction_addDelayedPath" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->addDelayedPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_isRenderingDelayedPaths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_isRenderingDelayedPaths" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->isRenderingDelayedPaths();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_handleTransparency__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_handleTransparency" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_handleTransparency" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbBool)(arg1)->handleTransparency(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_handleTransparency__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_handleTransparency" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)(arg1)->handleTransparency();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_handleTransparency(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_handleTransparency", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLRenderAction_handleTransparency__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGLRenderAction_handleTransparency__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_handleTransparency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::handleTransparency(SbBool)\n"
    "    SoGLRenderAction::handleTransparency()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setCurPass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setCurPass", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setCurPass" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setCurPass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLRenderAction_setCurPass" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setCurPass(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getCurPass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getCurPass" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (int)((SoGLRenderAction const *)arg1)->getCurPass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_abortNow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_abortNow" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)(arg1)->abortNow();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setRenderingIsRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setRenderingIsRemote", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setRenderingIsRemote" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setRenderingIsRemote" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setRenderingIsRemote(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getRenderingIsRemote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getRenderingIsRemote" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->getRenderingIsRemote();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_invalidateState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_invalidateState" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  (arg1)->invalidateState();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_addPreRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLPreRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_addPreRenderCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_addPreRenderCallback" "', argument " "2"" of type '" "SoGLPreRenderCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_addPreRenderCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addPreRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_removePreRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLPreRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_removePreRenderCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_removePreRenderCallback" "', argument " "2"" of type '" "SoGLPreRenderCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLRenderAction_removePreRenderCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removePreRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSortedLayersNumPasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setSortedLayersNumPasses", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setSortedLayersNumPasses" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setSortedLayersNumPasses" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setSortedLayersNumPasses(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getSortedLayersNumPasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getSortedLayersNumPasses" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (int)((SoGLRenderAction const *)arg1)->getSortedLayersNumPasses();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::SortedObjectOrderStrategy arg2 ;
  SoGLSortedObjectOrderCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "2"" of type '" "SoGLRenderAction::SortedObjectOrderStrategy""'");
  } 
  arg2 = static_cast< SoGLRenderAction::SortedObjectOrderStrategy >(val2);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "3"" of type '" "SoGLSortedObjectOrderCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->setSortedObjectOrderStrategy(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::SortedObjectOrderStrategy arg2 ;
  SoGLSortedObjectOrderCB *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "2"" of type '" "SoGLRenderAction::SortedObjectOrderStrategy""'");
  } 
  arg2 = static_cast< SoGLRenderAction::SortedObjectOrderStrategy >(val2);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "3"" of type '" "SoGLSortedObjectOrderCB *""'"); 
    }
  }
  (arg1)->setSortedObjectOrderStrategy(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SoGLRenderAction::SortedObjectOrderStrategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setSortedObjectOrderStrategy" "', argument " "2"" of type '" "SoGLRenderAction::SortedObjectOrderStrategy""'");
  } 
  arg2 = static_cast< SoGLRenderAction::SortedObjectOrderStrategy >(val2);
  (arg1)->setSortedObjectOrderStrategy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setSortedObjectOrderStrategy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setSortedObjectOrderStrategy", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoGLRenderAction_setSortedObjectOrderStrategy__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_setSortedObjectOrderStrategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::setSortedObjectOrderStrategy(SoGLRenderAction::SortedObjectOrderStrategy const,SoGLSortedObjectOrderCB *,void *)\n"
    "    SoGLRenderAction::setSortedObjectOrderStrategy(SoGLRenderAction::SortedObjectOrderStrategy const,SoGLSortedObjectOrderCB *)\n"
    "    SoGLRenderAction::setSortedObjectOrderStrategy(SoGLRenderAction::SortedObjectOrderStrategy const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setDelayedObjDepthWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setDelayedObjDepthWrite", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setDelayedObjDepthWrite" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderAction_setDelayedObjDepthWrite" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDelayedObjDepthWrite(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_getDelayedObjDepthWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_getDelayedObjDepthWrite" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->getDelayedObjDepthWrite();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_isRenderingTranspPaths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_isRenderingTranspPaths" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->isRenderingTranspPaths();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_isRenderingTranspBackfaces(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_isRenderingTranspBackfaces" "', argument " "1"" of type '" "SoGLRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SbBool)((SoGLRenderAction const *)arg1)->isRenderingTranspBackfaces();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setPassCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setPassCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoGLRenderAction_setPassCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setPassCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setPassCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLRenderAction_setPassCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoGLRenderAction_setPassCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_setPassCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::setPassCallback(SoGLRenderPassCB *const,void *const)\n"
    "    SoGLRenderAction::setPassCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setAbortCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_setAbortCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoGLRenderAction_setAbortCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_setAbortCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_setAbortCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void__SoGLRenderAction__AbortCode);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLRenderAction_setAbortCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoGLRenderAction_setAbortCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_setAbortCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::setAbortCallback(SoGLRenderAction::SoGLRenderAbortCB *const,void *const)\n"
    "    SoGLRenderAction::setAbortCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_addPreRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_addPreRenderCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoGLRenderAction_addPreRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_addPreRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_addPreRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLRenderAction_addPreRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoGLRenderAction_addPreRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_addPreRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::addPreRenderCallback(SoGLPreRenderCB *,void *)\n"
    "    SoGLRenderAction::addPreRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_removePreRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_removePreRenderCallback" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoGLRenderAction_removePreRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_removePreRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLRenderAction_removePreRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLRenderAction_removePreRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoGLRenderAction_removePreRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLRenderAction_removePreRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLRenderAction::removePreRenderCallback(SoGLPreRenderCB *,void *)\n"
    "    SoGLRenderAction::removePreRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLRenderAction_constructFromAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderAction_constructFromAction" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoGLRenderAction *)SoGLRenderAction_constructFromAction(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLRenderAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLRenderAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGLRenderAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_getTypeId" "', argument " "1"" of type '" "SoBoxHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  result = ((SoBoxHighlightRenderAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBoxHighlightRenderAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoxHighlightRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoBoxHighlightRenderAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoBoxHighlightRenderAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoxHighlightRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBoxHighlightRenderAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoBoxHighlightRenderAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_initClass", 0, 0, 0)) SWIG_fail;
  SoBoxHighlightRenderAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBoxHighlightRenderAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoBoxHighlightRenderAction *)new SoBoxHighlightRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBoxHighlightRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBoxHighlightRenderAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoBoxHighlightRenderAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoBoxHighlightRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoBoxHighlightRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoBoxHighlightRenderAction *)new SoBoxHighlightRenderAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBoxHighlightRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBoxHighlightRenderAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoBoxHighlightRenderAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoBoxHighlightRenderAction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoBoxHighlightRenderAction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoBoxHighlightRenderAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBoxHighlightRenderAction::SoBoxHighlightRenderAction()\n"
    "    SoBoxHighlightRenderAction::SoBoxHighlightRenderAction(SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoBoxHighlightRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoBoxHighlightRenderAction" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoxHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBoxHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBoxHighlightRenderAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBoxHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBoxHighlightRenderAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBoxHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBoxHighlightRenderAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBoxHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoBoxHighlightRenderAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoBoxHighlightRenderAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBoxHighlightRenderAction::apply(SoNode *)\n"
    "    SoBoxHighlightRenderAction::apply(SoPath *)\n"
    "    SoBoxHighlightRenderAction::apply(SoPathList const &,SbBool)\n"
    "    SoBoxHighlightRenderAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_setVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_setVisible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_setVisible" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBoxHighlightRenderAction_setVisible" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setVisible(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_isVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_isVisible" "', argument " "1"" of type '" "SoBoxHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  result = (SbBool)((SoBoxHighlightRenderAction const *)arg1)->isVisible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_setColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_setColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_setColor" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoxHighlightRenderAction_setColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoxHighlightRenderAction_setColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_getColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_getColor" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  result = (SbColor *) &(arg1)->getColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_setLinePattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_setLinePattern", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_setLinePattern" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBoxHighlightRenderAction_setLinePattern" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setLinePattern(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_getLinePattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_getLinePattern" "', argument " "1"" of type '" "SoBoxHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  result = (unsigned short)((SoBoxHighlightRenderAction const *)arg1)->getLinePattern();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_setLineWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoxHighlightRenderAction_setLineWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_setLineWidth" "', argument " "1"" of type '" "SoBoxHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBoxHighlightRenderAction_setLineWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setLineWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoxHighlightRenderAction_getLineWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoxHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoxHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoxHighlightRenderAction_getLineWidth" "', argument " "1"" of type '" "SoBoxHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoxHighlightRenderAction * >(argp1);
  result = (float)((SoBoxHighlightRenderAction const *)arg1)->getLineWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBoxHighlightRenderAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBoxHighlightRenderAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBoxHighlightRenderAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_getTypeId" "', argument " "1"" of type '" "SoLineHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  result = ((SoLineHighlightRenderAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLineHighlightRenderAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLineHighlightRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoLineHighlightRenderAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoLineHighlightRenderAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLineHighlightRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineHighlightRenderAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoLineHighlightRenderAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_initClass", 0, 0, 0)) SWIG_fail;
  SoLineHighlightRenderAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLineHighlightRenderAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoLineHighlightRenderAction *)new SoLineHighlightRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLineHighlightRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLineHighlightRenderAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoLineHighlightRenderAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoLineHighlightRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoLineHighlightRenderAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoLineHighlightRenderAction *)new SoLineHighlightRenderAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLineHighlightRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLineHighlightRenderAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoLineHighlightRenderAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoLineHighlightRenderAction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoLineHighlightRenderAction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoLineHighlightRenderAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLineHighlightRenderAction::SoLineHighlightRenderAction()\n"
    "    SoLineHighlightRenderAction::SoLineHighlightRenderAction(SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoLineHighlightRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoLineHighlightRenderAction" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLineHighlightRenderAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoLineHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoLineHighlightRenderAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoLineHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoLineHighlightRenderAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoLineHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoLineHighlightRenderAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoLineHighlightRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoLineHighlightRenderAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoLineHighlightRenderAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLineHighlightRenderAction::apply(SoNode *)\n"
    "    SoLineHighlightRenderAction::apply(SoPath *)\n"
    "    SoLineHighlightRenderAction::apply(SoPathList const &,SbBool)\n"
    "    SoLineHighlightRenderAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_setVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_setVisible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_setVisible" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineHighlightRenderAction_setVisible" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setVisible(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_isVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_isVisible" "', argument " "1"" of type '" "SoLineHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  result = (SbBool)((SoLineHighlightRenderAction const *)arg1)->isVisible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_setColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_setColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_setColor" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineHighlightRenderAction_setColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLineHighlightRenderAction_setColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_getColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_getColor" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  result = (SbColor *) &(arg1)->getColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_setLinePattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_setLinePattern", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_setLinePattern" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineHighlightRenderAction_setLinePattern" "', argument " "2"" of type '" "uint16_t""'");
  } 
  arg2 = static_cast< uint16_t >(val2);
  (arg1)->setLinePattern(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_getLinePattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint16_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_getLinePattern" "', argument " "1"" of type '" "SoLineHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  result = (uint16_t)((SoLineHighlightRenderAction const *)arg1)->getLinePattern();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_setLineWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineHighlightRenderAction_setLineWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_setLineWidth" "', argument " "1"" of type '" "SoLineHighlightRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineHighlightRenderAction_setLineWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setLineWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineHighlightRenderAction_getLineWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineHighlightRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineHighlightRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineHighlightRenderAction_getLineWidth" "', argument " "1"" of type '" "SoLineHighlightRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineHighlightRenderAction * >(argp1);
  result = (float)((SoLineHighlightRenderAction const *)arg1)->getLineWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLineHighlightRenderAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLineHighlightRenderAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLineHighlightRenderAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox3f *)new SbBox3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox3f" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbBox3f" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbBox3f" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  result = (SbBox3f *)new SbBox3f(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox3f" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3f" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBox3f *)new SbBox3f((SbVec3f const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbBox3f *)new SbBox3f((SbBox3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbBox3f *)new SbBox3f((SbBox3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3f" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbBox3f *)new SbBox3f((SbBox3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox3f", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox3f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3f__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox3f__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SbBox3f__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox3f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::SbBox3f()\n"
    "    SbBox3f::SbBox3f(float,float,float,float,float,float)\n"
    "    SbBox3f::SbBox3f(SbVec3f const &,SbVec3f const &)\n"
    "    SbBox3f::SbBox3f(SbBox3d const &)\n"
    "    SbBox3f::SbBox3f(SbBox3s const &)\n"
    "    SbBox3f::SbBox3f(SbBox3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_setBounds" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox3f_setBounds" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox3f_setBounds" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox3f_setBounds" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbBox3f_setBounds" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbBox3f_setBounds" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  result = (SbBox3f *) &(arg1)->setBounds(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_setBounds" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_setBounds" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_setBounds" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbBox3f *) &(arg1)->setBounds((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_setBounds" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  result = (SbBox3f *) &(arg1)->setBounds((SbBox3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_setBounds" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (SbBox3f *) &(arg1)->setBounds((SbBox3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_setBounds" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  result = (SbBox3f *) &(arg1)->setBounds((SbBox3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_setBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3f_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbBox3f_setBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::setBounds(float,float,float,float,float,float)\n"
    "    SbBox3f::setBounds(SbVec3f const &,SbVec3f const &)\n"
    "    SbBox3f::setBounds(SbBox3d const &)\n"
    "    SbBox3f::setBounds(SbBox3s const &)\n"
    "    SbBox3f::setBounds(SbBox3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  float *arg6 = 0 ;
  float *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getBounds" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getBounds" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_getBounds" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3f_getBounds" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox3f_getBounds" "', argument " "5"" of type '" "float &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "5"" of type '" "float &""'"); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbBox3f_getBounds" "', argument " "6"" of type '" "float &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "6"" of type '" "float &""'"); 
  }
  arg6 = reinterpret_cast< float * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SbBox3f_getBounds" "', argument " "7"" of type '" "float &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "7"" of type '" "float &""'"); 
  }
  arg7 = reinterpret_cast< float * >(argp7);
  ((SbBox3f const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getBounds" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getBounds" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_getBounds" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getBounds" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ((SbBox3f const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_getBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3f_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SbBox3f_getBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::getBounds(float &,float &,float &,float &,float &,float &) const\n"
    "    SbBox3f::getBounds(SbVec3f &,SbVec3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getMin" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbVec3f *) &((SbBox3f const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getMin" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbVec3f *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3f_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3f_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::getMin() const\n"
    "    SbBox3f::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getMax" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbVec3f *) &((SbBox3f const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getMax" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbVec3f *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3f_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3f_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::getMax() const\n"
    "    SbBox3f::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_extendBy" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->extendBy((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_extendBy" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  (arg1)->extendBy((SbBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::extendBy(SbVec3f const &)\n"
    "    SbBox3f::extendBy(SbBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_transform" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->transform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_makeEmpty" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_isEmpty" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbBool)((SbBox3f const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_hasVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_hasVolume" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbBool)((SbBox3f const *)arg1)->hasVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getVolume" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (float)((SbBox3f const *)arg1)->getVolume();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_intersect" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbBox3f const *)arg1)->intersect((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_intersect" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)((SbBox3f const *)arg1)->intersect((SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3f_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::intersect(SbVec3f const &) const\n"
    "    SbBox3f::intersect(SbBox3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getClosestPoint" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = ((SbBox3f const *)arg1)->getClosestPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_outside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_outside", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_outside" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_outside" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_outside" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (SbBool)((SbBox3f const *)arg1)->outside((SbMatrix const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getCenter" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = ((SbBox3f const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_getOrigin", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getOrigin" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getOrigin" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getOrigin" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_getOrigin" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getOrigin" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3f_getOrigin" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getOrigin" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ((SbBox3f const *)arg1)->getOrigin(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getSize" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getSize" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSize" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_getSize" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSize" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3f_getSize" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSize" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ((SbBox3f const *)arg1)->getSize(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getSize" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = ((SbBox3f const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3f_getSize", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3f_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbBox3f_getSize__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3f_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3f::getSize(float &,float &,float &) const\n"
    "    SbBox3f::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3f_getSpan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_getSpan", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_getSpan" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3f_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3f_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ((SbBox3f const *)arg1)->getSpan((SbVec3f const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f_output" "', argument " "1"" of type '" "SbBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbBox3f const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f___eq__" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f___eq__" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f___eq__" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (int)SbBox3f___eq__(arg1,(SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox3f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3f___ne__" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3f___ne__" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3f___ne__" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (int)SbBox3f___ne__(arg1,(SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbBox3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox3f" "', argument " "1"" of type '" "SbBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbMatrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbMatrix *)new SbMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbMatrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  float arg8 ;
  float arg9 ;
  float arg10 ;
  float arg11 ;
  float arg12 ;
  float arg13 ;
  float arg14 ;
  float arg15 ;
  float arg16 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  float val14 ;
  int ecode14 = 0 ;
  float val15 ;
  int ecode15 = 0 ;
  float val16 ;
  int ecode16 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbMatrix" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbMatrix" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbMatrix" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbMatrix" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbMatrix" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbMatrix" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SbMatrix" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SbMatrix" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_float(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SbMatrix" "', argument " "9"" of type '" "float""'");
  } 
  arg9 = static_cast< float >(val9);
  ecode10 = SWIG_AsVal_float(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SbMatrix" "', argument " "10"" of type '" "float""'");
  } 
  arg10 = static_cast< float >(val10);
  ecode11 = SWIG_AsVal_float(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SbMatrix" "', argument " "11"" of type '" "float""'");
  } 
  arg11 = static_cast< float >(val11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SbMatrix" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  ecode13 = SWIG_AsVal_float(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SbMatrix" "', argument " "13"" of type '" "float""'");
  } 
  arg13 = static_cast< float >(val13);
  ecode14 = SWIG_AsVal_float(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SbMatrix" "', argument " "14"" of type '" "float""'");
  } 
  arg14 = static_cast< float >(val14);
  ecode15 = SWIG_AsVal_float(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SbMatrix" "', argument " "15"" of type '" "float""'");
  } 
  arg15 = static_cast< float >(val15);
  ecode16 = SWIG_AsVal_float(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SbMatrix" "', argument " "16"" of type '" "float""'");
  } 
  arg16 = static_cast< float >(val16);
  result = (SbMatrix *)new SbMatrix(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbMatrix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMat *arg1 = 0 ;
  SbMat temp1 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbMat_array(swig_obj[0], temp1);
    arg1 = &temp1;
  }
  result = (SbMatrix *)new SbMatrix((SbMat const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbMatrix__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_a_4__a_4__float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbMatrix" "', argument " "1"" of type '" "SbMat const *""'"); 
  }
  arg1 = reinterpret_cast< SbMat * >(argp1);
  result = (SbMatrix *)new SbMatrix((SbMat const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbMatrix__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbMatrix" "', argument " "1"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbMatrix" "', argument " "1"" of type '" "SbDPMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = (SbMatrix *)new SbMatrix((SbDPMatrix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[17] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbMatrix", 0, 16, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbMatrix__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_4__a_4__float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbMatrix__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbMatrix__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbMatrix__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_float(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_float(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_float(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SbMatrix__SWIG_1(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::SbMatrix()\n"
    "    SbMatrix::SbMatrix(float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const)\n"
    "    SbMatrix::SbMatrix(SbMat const &)\n"
    "    SbMatrix::SbMatrix(SbMat const *)\n"
    "    SbMatrix::SbMatrix(SbDPMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbMatrix" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMat temp2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setValue" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  {
    convert_SbMat_array(swig_obj[1], temp2);
    arg2 = &temp2;
  }
  (arg1)->setValue((SbMat const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setValue" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setValue" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setValue" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  (arg1)->setValue((SbDPMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setValue" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setValue" "', argument " "2"" of type '" "float const *""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->setValue((float const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbMatrix_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::setValue(SbMat const &)\n"
    "    SbMatrix::setValue(SbDPMatrix const &)\n"
    "    SbMatrix::setValue(float const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_getValue" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = (SbMat *) &((SbMatrix const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("([ffff][ffff][ffff][ffff])",
      (double)(*result)[0][0],
      (double)(*result)[0][1],
      (double)(*result)[0][2],
      (double)(*result)[0][3],
      
      (double)(*result)[1][0],
      (double)(*result)[1][1],
      (double)(*result)[1][2],
      (double)(*result)[1][3],
      
      (double)(*result)[2][0],
      (double)(*result)[2][1],
      (double)(*result)[2][2],
      (double)(*result)[2][3],
      
      (double)(*result)[3][0],
      (double)(*result)[3][1],
      (double)(*result)[3][2],
      (double)(*result)[3][3]);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_makeIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_makeIdentity" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  (arg1)->makeIdentity();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setRotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_setRotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setRotate" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setRotate" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setRotate" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  (arg1)->setRotate((SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_inverse" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = ((SbMatrix const *)arg1)->inverse();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_det3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_det3" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbMatrix_det3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbMatrix_det3" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbMatrix_det3" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbMatrix_det3" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbMatrix_det3" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbMatrix_det3" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (float)((SbMatrix const *)arg1)->det3(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_det3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_det3" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = (float)((SbMatrix const *)arg1)->det3();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_det3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_det3", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbMatrix_det3__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbMatrix_det3__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_det3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::det3(int,int,int,int,int,int) const\n"
    "    SbMatrix::det3() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_det4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_det4" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = (float)((SbMatrix const *)arg1)->det4();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_equals" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_equals" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_equals" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbMatrix_equals" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)((SbMatrix const *)arg1)->equals((SbMatrix const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMat temp2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_getValue" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  {
    convert_SbMat_array(swig_obj[1], temp2);
    arg2 = &temp2;
  }
  ((SbMatrix const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbMatrix_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbMatrix_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::getValue() const\n"
    "    SbMatrix::getValue(SbMat &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_identity", 0, 0, 0)) SWIG_fail;
  result = SbMatrix::identity();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setScale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setScale" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbMatrix_setScale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setScale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setScale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setScale" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setScale((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setScale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_setScale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_setScale__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbMatrix_setScale__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_setScale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::setScale(float const)\n"
    "    SbMatrix::setScale(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setTranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_setTranslate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setTranslate" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setTranslate" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTranslate" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setTranslate((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setTransform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setTransform" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  (arg1)->setTransform((SbVec3f const &)*arg2,(SbRotation const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setTransform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setTransform" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbMatrix_setTransform" "', argument " "5"" of type '" "SbRotation const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "5"" of type '" "SbRotation const &""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  (arg1)->setTransform((SbVec3f const &)*arg2,(SbRotation const &)*arg3,(SbVec3f const &)*arg4,(SbRotation const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setTransform__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  SbVec3f *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_setTransform" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbMatrix_setTransform" "', argument " "5"" of type '" "SbRotation const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "5"" of type '" "SbRotation const &""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbMatrix_setTransform" "', argument " "6"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_setTransform" "', argument " "6"" of type '" "SbVec3f const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3f * >(argp6);
  (arg1)->setTransform((SbVec3f const &)*arg2,(SbRotation const &)*arg3,(SbVec3f const &)*arg4,(SbRotation const &)*arg5,(SbVec3f const &)*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_setTransform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_setTransform", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbMatrix_setTransform__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbMatrix_setTransform__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SbMatrix_setTransform__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_setTransform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::setTransform(SbVec3f const &,SbRotation const &,SbVec3f const &)\n"
    "    SbMatrix::setTransform(SbVec3f const &,SbRotation const &,SbVec3f const &,SbRotation const &)\n"
    "    SbMatrix::setTransform(SbVec3f const &,SbRotation const &,SbVec3f const &,SbRotation const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getTransform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_getTransform" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_getTransform" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_getTransform" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_getTransform" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_getTransform" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbMatrix_getTransform" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_getTransform" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbMatrix_getTransform" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_getTransform" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  ((SbMatrix const *)arg1)->getTransform(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_factor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbMatrix *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  SbMatrix *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_factor", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_factor" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_factor" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_factor" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_factor" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_factor" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbMatrix_factor" "', argument " "4"" of type '" "SbMatrix &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_factor" "', argument " "4"" of type '" "SbMatrix &""'"); 
  }
  arg4 = reinterpret_cast< SbMatrix * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbMatrix_factor" "', argument " "5"" of type '" "SbVec3f &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_factor" "', argument " "5"" of type '" "SbVec3f &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbMatrix_factor" "', argument " "6"" of type '" "SbMatrix &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_factor" "', argument " "6"" of type '" "SbMatrix &""'"); 
  }
  arg6 = reinterpret_cast< SbMatrix * >(argp6);
  result = (SbBool)((SbMatrix const *)arg1)->factor(*arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_LUDecomposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  int *arg2 = (int *)0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_LUDecomposition", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_LUDecomposition" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_LUDecomposition" "', argument " "2"" of type '" "int [4]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_LUDecomposition" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_LUDecomposition" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  result = (SbBool)(arg1)->LUDecomposition(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_LUBackSubstitution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  int *arg2 = (int *)0 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_LUBackSubstitution", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_LUBackSubstitution" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_LUBackSubstitution" "', argument " "2"" of type '" "int [4]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_LUBackSubstitution" "', argument " "3"" of type '" "float [4]""'"); 
  } 
  arg3 = reinterpret_cast< float * >(argp3);
  ((SbMatrix const *)arg1)->LUBackSubstitution(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_transpose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_transpose" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = ((SbMatrix const *)arg1)->transpose();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_multRight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multRight" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multRight" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multRight" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (SbMatrix *) &(arg1)->multRight((SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_multLeft", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multLeft" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multLeft" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multLeft" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (SbMatrix *) &(arg1)->multLeft((SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multMatrixVec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbVec3f();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_multMatrixVec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multMatrixVec" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multMatrixVec" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multMatrixVec" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ((SbMatrix const *)arg1)->multMatrixVec((SbVec3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbVec3f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multVecMatrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  {
    arg3 = new SbVec3f();
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multVecMatrix" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ((SbMatrix const *)arg1)->multVecMatrix((SbVec3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbVec3f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multDirMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbVec3f();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_multDirMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multDirMatrix" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multDirMatrix" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multDirMatrix" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ((SbMatrix const *)arg1)->multDirMatrix((SbVec3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbVec3f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multLineMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbLine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_multLineMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multLineMatrix" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multLineMatrix" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multLineMatrix" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbLine,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbMatrix_multLineMatrix" "', argument " "3"" of type '" "SbLine &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multLineMatrix" "', argument " "3"" of type '" "SbLine &""'"); 
  }
  arg3 = reinterpret_cast< SbLine * >(argp3);
  ((SbMatrix const *)arg1)->multLineMatrix((SbLine const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multVecMatrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  {
    arg3 = new SbVec4f();
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_multVecMatrix" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  ((SbMatrix const *)arg1)->multVecMatrix((SbVec4f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbVec4f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_multVecMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_multVecMatrix", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_multVecMatrix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_multVecMatrix__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_multVecMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::multVecMatrix(SbVec3f const &,SbVec3f &) const\n"
    "    SbMatrix::multVecMatrix(SbVec4f const &,SbVec4f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_output" "', argument " "1"" of type '" "SbMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbMatrix const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___imul__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___imul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___imul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (SbMatrix *) &(arg1)->operator *=((SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getTransform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_getTransform" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = (PyObject *)SbMatrix_getTransform__SWIG_1(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getTransform__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix_getTransform" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix_getTransform" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix_getTransform" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (PyObject *)SbMatrix_getTransform__SWIG_2(arg1,*arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMatrix_getTransform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix_getTransform", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbMatrix_getTransform__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix_getTransform__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbMatrix_getTransform__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbMatrix_getTransform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbMatrix::getTransform(SbVec3f &,SbRotation &,SbVec3f &,SbRotation &) const\n"
    "    SbMatrix::getTransform()\n"
    "    SbMatrix::getTransform(SbVec3f &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbMatrix___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___mul__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = SbMatrix___mul____SWIG_0(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___mul__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___mul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___mul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SbMatrix___mul____SWIG_1(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbMatrix___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbMatrix___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___rmul__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___rmul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___rmul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SbMatrix___rmul__(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___eq__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___eq__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___eq__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (int)SbMatrix___eq__(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___ne__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbMatrix___ne__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbMatrix___ne__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (int)SbMatrix___ne__(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbMatrix___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbMatrix___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMatrix___getitem__" "', argument " "1"" of type '" "SbMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbMatrix___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float *)SbMatrix___getitem__(arg1,arg2);
  {
    resultobj = Py_BuildValue("(fff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbXfBox3f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbXfBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbXfBox3f *)new SbXfBox3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbXfBox3f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbXfBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbXfBox3f" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbXfBox3f" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbXfBox3f" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbXfBox3f" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbXfBox3f *)new SbXfBox3f((SbVec3f const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbXfBox3f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbXfBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbXfBox3f" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbXfBox3f" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbXfBox3f *)new SbXfBox3f((SbBox3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbXfBox3f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbXfBox3f", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbXfBox3f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbXfBox3f__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbXfBox3f__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbXfBox3f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbXfBox3f::SbXfBox3f()\n"
    "    SbXfBox3f::SbXfBox3f(SbVec3f const &,SbVec3f const &)\n"
    "    SbXfBox3f::SbXfBox3f(SbBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbXfBox3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbXfBox3f" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_setTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f_setTransform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_setTransform" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_setTransform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_setTransform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setTransform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_getTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_getTransform" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  result = (SbMatrix *) &((SbXfBox3f const *)arg1)->getTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_getInverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_getInverse" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  result = (SbMatrix *) &((SbXfBox3f const *)arg1)->getInverse();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_getCenter" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  result = ((SbXfBox3f const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_extendBy" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->extendBy((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_extendBy" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  (arg1)->extendBy((SbBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_extendBy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_extendBy" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_extendBy" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  (arg1)->extendBy((SbXfBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbXfBox3f_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_extendBy__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbXfBox3f_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbXfBox3f::extendBy(SbVec3f const &)\n"
    "    SbXfBox3f::extendBy(SbBox3f const &)\n"
    "    SbXfBox3f::extendBy(SbXfBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_intersect" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbXfBox3f const *)arg1)->intersect((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_intersect" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)((SbXfBox3f const *)arg1)->intersect((SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_intersect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_intersect" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_intersect" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  result = (SbBool)((SbXfBox3f const *)arg1)->intersect((SbXfBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbXfBox3f_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_intersect__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbXfBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbXfBox3f_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbXfBox3f_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbXfBox3f::intersect(SbVec3f const &) const\n"
    "    SbXfBox3f::intersect(SbBox3f const &) const\n"
    "    SbXfBox3f::intersect(SbXfBox3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_getSpan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f_getSpan", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_getSpan" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbXfBox3f_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbXfBox3f_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ((SbXfBox3f const *)arg1)->getSpan((SbVec3f const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_project" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  result = ((SbXfBox3f const *)arg1)->project();
  resultobj = SWIG_NewPointerObj((new SbBox3f(result)), SWIGTYPE_p_SbBox3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_transform" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->transform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_getVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_getVolume" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  result = (float)((SbXfBox3f const *)arg1)->getVolume();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f_output" "', argument " "1"" of type '" "SbXfBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbXfBox3f const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f___eq__" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f___eq__" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f___eq__" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  result = (int)SbXfBox3f___eq__(arg1,(SbXfBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbXfBox3f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbXfBox3f *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbXfBox3f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbXfBox3f___ne__" "', argument " "1"" of type '" "SbXfBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SbXfBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbXfBox3f___ne__" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbXfBox3f___ne__" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  result = (int)SbXfBox3f___ne__(arg1,(SbXfBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SbXfBox3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbXfBox3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbXfBox3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getTypeId" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = ((SoGetBoundingBoxAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGetBoundingBoxAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGetBoundingBoxAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoGetBoundingBoxAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetBoundingBoxAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGetBoundingBoxAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_initClass", 0, 0, 0)) SWIG_fail;
  SoGetBoundingBoxAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGetBoundingBoxAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGetBoundingBoxAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGetBoundingBoxAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoGetBoundingBoxAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoGetBoundingBoxAction *)new SoGetBoundingBoxAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGetBoundingBoxAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoGetBoundingBoxAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGetBoundingBoxAction" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setViewportRegion" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getViewportRegion" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbViewportRegion *) &((SoGetBoundingBoxAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getBoundingBox" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = ((SoGetBoundingBoxAction const *)arg1)->getBoundingBox();
  resultobj = SWIG_NewPointerObj((new SbBox3f(result)), SWIGTYPE_p_SbBox3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getXfBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbXfBox3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getXfBoundingBox" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbXfBox3f *) &(arg1)->getXfBoundingBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getCenter" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbVec3f *) &((SoGetBoundingBoxAction const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setInCameraSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_setInCameraSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setInCameraSpace" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetBoundingBoxAction_setInCameraSpace" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setInCameraSpace(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_isInCameraSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_isInCameraSpace" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbBool)((SoGetBoundingBoxAction const *)arg1)->isInCameraSpace();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setResetPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SbBool arg3 ;
  SoGetBoundingBoxAction::ResetType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "4"" of type '" "SoGetBoundingBoxAction::ResetType""'");
  } 
  arg4 = static_cast< SoGetBoundingBoxAction::ResetType >(val4);
  (arg1)->setResetPath((SoPath const *)arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setResetPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setResetPath((SoPath const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setResetPath__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_setResetPath" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->setResetPath((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setResetPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_setResetPath", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetBoundingBoxAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGetBoundingBoxAction_setResetPath__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetBoundingBoxAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGetBoundingBoxAction_setResetPath__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetBoundingBoxAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGetBoundingBoxAction_setResetPath__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGetBoundingBoxAction_setResetPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGetBoundingBoxAction::setResetPath(SoPath const *,SbBool const,SoGetBoundingBoxAction::ResetType const)\n"
    "    SoGetBoundingBoxAction::setResetPath(SoPath const *,SbBool const)\n"
    "    SoGetBoundingBoxAction::setResetPath(SoPath const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getResetPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getResetPath" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SoPath *)((SoGetBoundingBoxAction const *)arg1)->getResetPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_isResetPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_isResetPath" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbBool)((SoGetBoundingBoxAction const *)arg1)->isResetPath();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_isResetBefore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_isResetBefore" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbBool)((SoGetBoundingBoxAction const *)arg1)->isResetBefore();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_getWhatReset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGetBoundingBoxAction::ResetType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_getWhatReset" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SoGetBoundingBoxAction::ResetType)((SoGetBoundingBoxAction const *)arg1)->getWhatReset();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_checkResetBefore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_checkResetBefore" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  (arg1)->checkResetBefore();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_checkResetAfter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_checkResetAfter" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  (arg1)->checkResetAfter();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  (arg1)->extendBy((SbBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_extendBy" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  (arg1)->extendBy((SbXfBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetBoundingBoxAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbXfBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGetBoundingBoxAction_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetBoundingBoxAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGetBoundingBoxAction_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGetBoundingBoxAction_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGetBoundingBoxAction::extendBy(SbBox3f const &)\n"
    "    SoGetBoundingBoxAction::extendBy(SbXfBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_setCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetBoundingBoxAction_setCenter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_setCenter" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetBoundingBoxAction_setCenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetBoundingBoxAction_setCenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGetBoundingBoxAction_setCenter" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setCenter((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_isCenterSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_isCenterSet" "', argument " "1"" of type '" "SoGetBoundingBoxAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  result = (SbBool)((SoGetBoundingBoxAction const *)arg1)->isCenterSet();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetBoundingBoxAction_resetCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetBoundingBoxAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetBoundingBoxAction_resetCenter" "', argument " "1"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetBoundingBoxAction * >(argp1);
  (arg1)->resetCenter();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGetBoundingBoxAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGetBoundingBoxAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGetBoundingBoxAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4f *)new SbVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[4] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec4f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec4f *)new SbVec4f((float const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4f" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbVec4f *)new SbVec4f(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (SbVec4f *)new SbVec4f((SbVec4d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (SbVec4f *)new SbVec4f((SbVec4b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (SbVec4f *)new SbVec4f((SbVec4s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4f" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (SbVec4f *)new SbVec4f((SbVec4i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4f", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4f__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4f__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec4f__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4f__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4f::SbVec4f()\n"
    "    SbVec4f::SbVec4f(float const [4])\n"
    "    SbVec4f::SbVec4f(float,float,float,float)\n"
    "    SbVec4f::SbVec4f(SbVec4d const &)\n"
    "    SbVec4f::SbVec4f(SbVec4b const &)\n"
    "    SbVec4f::SbVec4f(SbVec4s const &)\n"
    "    SbVec4f::SbVec4f(SbVec4i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec4f *) &(arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = (SbVec4f *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4f *) &(arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4b * >(argp2);
  result = (SbVec4f *) &(arg1)->setValue((SbVec4b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4f *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_setValue" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4f *) &(arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4f_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4f_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec4f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4f_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4f::setValue(float const [4])\n"
    "    SbVec4f::setValue(float,float,float,float)\n"
    "    SbVec4f::setValue(SbVec4d const &)\n"
    "    SbVec4f::setValue(SbVec4b const &)\n"
    "    SbVec4f::setValue(SbVec4s const &)\n"
    "    SbVec4f::setValue(SbVec4i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_getValue" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (float *)((SbVec4f const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_equals" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_equals" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_equals" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4f_equals" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)((SbVec4f const *)arg1)->equals((SbVec4f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_dot" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_dot" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_dot" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (float)((SbVec4f const *)arg1)->dot((SbVec4f const &)*arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_getReal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f_getReal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_getReal" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f_getReal" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f_getReal" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ((SbVec4f const *)arg1)->getReal(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_length" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (float)((SbVec4f const *)arg1)->length();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_sqrLength" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (float)((SbVec4f const *)arg1)->sqrLength();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_negate" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_normalize" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (float)(arg1)->normalize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___imul__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___imul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec4f *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___itruediv__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___itruediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbVec4f *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___iadd__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___iadd__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___iadd__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4f *) &(arg1)->operator +=((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___isub__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___isub__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___isub__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4f *) &(arg1)->operator -=((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___neg__" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = ((SbVec4f const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f_output" "', argument " "1"" of type '" "SbVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec4f const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___add__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___add__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___add__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = SbVec4f___add__(arg1,(SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___sub__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___sub__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___sub__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = SbVec4f___sub__(arg1,(SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbVec4f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___mul__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec4f___mul____SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___mul__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___mul__" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = SbVec4f___mul____SWIG_1(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4f___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4f___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4f___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___rmul__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec4f___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___div__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec4f___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___truediv__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___truediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec4f___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___eq__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___eq__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___eq__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (int)SbVec4f___eq__(arg1,(SbVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4f___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___nq__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4f___nq__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4f___nq__" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (int)SbVec4f___nq__(arg1,(SbVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___getitem__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SbVec4f___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4f___setitem__" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4f___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SbVec4f___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4f" "', argument " "1"" of type '" "SbVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbRotation *)new SbRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbRotation" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbRotation *)new SbRotation((SbVec3f const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[4] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec4f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbRotation *)new SbRotation((float const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbRotation" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbRotation" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbRotation" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbRotation" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbRotation *)new SbRotation(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  result = (SbRotation *)new SbRotation((SbMatrix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbRotation" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbRotation *)new SbRotation((SbVec3f const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbRotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbRotation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbRotation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbRotation__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbRotation__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbRotation__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbRotation__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbRotation__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbRotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbRotation::SbRotation()\n"
    "    SbRotation::SbRotation(SbVec3f const &,float const)\n"
    "    SbRotation::SbRotation(float const [4])\n"
    "    SbRotation::SbRotation(float const,float const,float const,float const)\n"
    "    SbRotation::SbRotation(SbMatrix const &)\n"
    "    SbRotation::SbRotation(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbRotation_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_getValue" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  result = (float *)((SbRotation const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_setValue" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbRotation_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbRotation_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = (SbRotation *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_getAxisAngle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbVec3f();
  }
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_getAxisAngle" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ((SbRotation const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbVec3f, 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_getMatrix" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ((SbRotation const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_invert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_invert" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  result = (SbRotation *) &(arg1)->invert();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_inverse" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  result = ((SbRotation const *)arg1)->inverse();
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_setValue" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbRotation *) &(arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_setValue" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (SbRotation *) &(arg1)->setValue((SbMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_setValue" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbRotation *) &(arg1)->setValue((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_setValue" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbRotation_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbRotation *) &(arg1)->setValue((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbRotation_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbRotation_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbRotation_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbRotation_setValue__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbRotation_setValue__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbRotation_setValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbRotation_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbRotation::setValue(float const,float const,float const,float const)\n"
    "    SbRotation::setValue(float const [4])\n"
    "    SbRotation::setValue(SbMatrix const &)\n"
    "    SbRotation::setValue(SbVec3f const &,float const)\n"
    "    SbRotation::setValue(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbRotation___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___imul__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation___imul__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation___imul__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  result = (SbRotation *) &(arg1)->operator *=((SbRotation const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___imul__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbRotation___imul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbRotation *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbRotation___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbRotation___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbRotation___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbRotation___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbRotation::operator *=(SbRotation const &)\n"
    "    SbRotation::operator *=(float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbRotation_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_equals" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_equals" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_equals" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbRotation_equals" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbBool)((SbRotation const *)arg1)->equals((SbRotation const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_multVec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbVec3f();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_multVec", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_multVec" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_multVec" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_multVec" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ((SbRotation const *)arg1)->multVec((SbVec3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbVec3f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_scaleAngle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_scaleAngle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_scaleAngle" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbRotation_scaleAngle" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleAngle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_slerp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_slerp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_slerp" "', argument " "1"" of type '" "SbRotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_slerp" "', argument " "1"" of type '" "SbRotation const &""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation_slerp" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation_slerp" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbRotation_slerp" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = SbRotation::slerp((SbRotation const &)*arg1,(SbRotation const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_identity", 0, 0, 0)) SWIG_fail;
  result = SbRotation::identity();
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_toString" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  result = ((SbRotation const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_fromString" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation_output" "', argument " "1"" of type '" "SbRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbRotation const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRotation___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___mul__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation___mul__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation___mul__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  result = SbRotation___mul____SWIG_0(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbRotation___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___mul__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbRotation___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbRotation___mul____SWIG_1(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbRotation___mul____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___mul__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation___mul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation___mul__" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SbRotation___mul____SWIG_2(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbRotation___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbRotation___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbRotation___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbRotation___mul____SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbRotation___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbRotation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___eq__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation___eq__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation___eq__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  result = (int)SbRotation___eq__(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbRotation___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbRotation___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRotation___nq__" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbRotation___nq__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbRotation___nq__" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  result = (int)SbRotation___nq__(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbRotation" "', argument " "1"" of type '" "SbRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbRotation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getTypeId" "', argument " "1"" of type '" "SoGetMatrixAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = ((SoGetMatrixAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetMatrixAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGetMatrixAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetMatrixAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetMatrixAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGetMatrixAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoGetMatrixAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetMatrixAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetMatrixAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetMatrixAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGetMatrixAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetMatrixAction_initClass", 0, 0, 0)) SWIG_fail;
  SoGetMatrixAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGetMatrixAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGetMatrixAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGetMatrixAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoGetMatrixAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoGetMatrixAction *)new SoGetMatrixAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGetMatrixAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoGetMatrixAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGetMatrixAction" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetMatrixAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_setViewportRegion" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGetMatrixAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetMatrixAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getViewportRegion" "', argument " "1"" of type '" "SoGetMatrixAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = (SbViewportRegion *) &((SoGetMatrixAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getMatrix" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = (SbMatrix *) &(arg1)->getMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getInverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getInverse" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = (SbMatrix *) &(arg1)->getInverse();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getTextureMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getTextureMatrix" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = (SbMatrix *) &(arg1)->getTextureMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetMatrixAction_getTextureInverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetMatrixAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetMatrixAction_getTextureInverse" "', argument " "1"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetMatrixAction * >(argp1);
  result = (SbMatrix *) &(arg1)->getTextureInverse();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGetMatrixAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGetMatrixAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGetMatrixAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getTypeId" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = ((SoGetPrimitiveCountAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGetPrimitiveCountAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetPrimitiveCountAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGetPrimitiveCountAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoGetPrimitiveCountAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGetPrimitiveCountAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGetPrimitiveCountAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_initClass", 0, 0, 0)) SWIG_fail;
  SoGetPrimitiveCountAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGetPrimitiveCountAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoGetPrimitiveCountAction *)new SoGetPrimitiveCountAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGetPrimitiveCountAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGetPrimitiveCountAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoGetPrimitiveCountAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGetPrimitiveCountAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoGetPrimitiveCountAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoGetPrimitiveCountAction *)new SoGetPrimitiveCountAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGetPrimitiveCountAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGetPrimitiveCountAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoGetPrimitiveCountAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoGetPrimitiveCountAction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoGetPrimitiveCountAction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoGetPrimitiveCountAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGetPrimitiveCountAction::SoGetPrimitiveCountAction()\n"
    "    SoGetPrimitiveCountAction::SoGetPrimitiveCountAction(SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoGetPrimitiveCountAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGetPrimitiveCountAction" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getTriangleCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getTriangleCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (int)((SoGetPrimitiveCountAction const *)arg1)->getTriangleCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getLineCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getLineCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (int)((SoGetPrimitiveCountAction const *)arg1)->getLineCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getPointCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getPointCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (int)((SoGetPrimitiveCountAction const *)arg1)->getPointCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getTextCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getTextCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (int)((SoGetPrimitiveCountAction const *)arg1)->getTextCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getImageCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getImageCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (int)((SoGetPrimitiveCountAction const *)arg1)->getImageCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_containsNoPrimitives(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_containsNoPrimitives" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (SbBool)(arg1)->containsNoPrimitives();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_containsNonTriangleShapes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_containsNonTriangleShapes" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (SbBool)(arg1)->containsNonTriangleShapes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_is3DTextCountedAsTriangles" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (SbBool)(arg1)->is3DTextCountedAsTriangles();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_setCount3DTextAsTriangles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_setCount3DTextAsTriangles", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_setCount3DTextAsTriangles" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_setCount3DTextAsTriangles" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCount3DTextAsTriangles(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_canApproximateCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_canApproximateCount" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (SbBool)(arg1)->canApproximateCount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_setCanApproximate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_setCanApproximate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_setCanApproximate" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_setCanApproximate" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCanApproximate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_setDecimationValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  SoDecimationTypeElement::Type arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_setDecimationValue" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_setDecimationValue" "', argument " "2"" of type '" "SoDecimationTypeElement::Type""'");
  } 
  arg2 = static_cast< SoDecimationTypeElement::Type >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGetPrimitiveCountAction_setDecimationValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDecimationValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_setDecimationValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  SoDecimationTypeElement::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_setDecimationValue" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_setDecimationValue" "', argument " "2"" of type '" "SoDecimationTypeElement::Type""'");
  } 
  arg2 = static_cast< SoDecimationTypeElement::Type >(val2);
  (arg1)->setDecimationValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_setDecimationValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_setDecimationValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetPrimitiveCountAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGetPrimitiveCountAction_setDecimationValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGetPrimitiveCountAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGetPrimitiveCountAction_setDecimationValue__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGetPrimitiveCountAction_setDecimationValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGetPrimitiveCountAction::setDecimationValue(SoDecimationTypeElement::Type,float)\n"
    "    SoGetPrimitiveCountAction::setDecimationValue(SoDecimationTypeElement::Type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getDecimationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDecimationTypeElement::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getDecimationType" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (SoDecimationTypeElement::Type)(arg1)->getDecimationType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_getDecimationPercentage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_getDecimationPercentage" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  result = (float)(arg1)->getDecimationPercentage();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addNumTriangles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addNumTriangles", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addNumTriangles" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_addNumTriangles" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addNumTriangles(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addNumLines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addNumLines", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addNumLines" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_addNumLines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addNumLines(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addNumPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addNumPoints", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addNumPoints" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_addNumPoints" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addNumPoints(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addNumText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addNumText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addNumText" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_addNumText" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addNumText(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_addNumImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGetPrimitiveCountAction_addNumImage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_addNumImage" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGetPrimitiveCountAction_addNumImage" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addNumImage(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_incNumTriangles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_incNumTriangles" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  (arg1)->incNumTriangles();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_incNumLines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_incNumLines" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  (arg1)->incNumLines();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_incNumPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_incNumPoints" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  (arg1)->incNumPoints();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_incNumText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_incNumText" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  (arg1)->incNumText();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGetPrimitiveCountAction_incNumImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGetPrimitiveCountAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGetPrimitiveCountAction_incNumImage" "', argument " "1"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp1);
  (arg1)->incNumImage();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGetPrimitiveCountAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGetPrimitiveCountAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGetPrimitiveCountAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoHandleEventAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getTypeId" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = ((SoHandleEventAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoHandleEventAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoHandleEventAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoHandleEventAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoHandleEventAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoHandleEventAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoHandleEventAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoHandleEventAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_initClass", 0, 0, 0)) SWIG_fail;
  SoHandleEventAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoHandleEventAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoHandleEventAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoHandleEventAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoHandleEventAction *)new SoHandleEventAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleEventAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoHandleEventAction" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setViewportRegion" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleEventAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoHandleEventAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getViewportRegion" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SbViewportRegion *) &((SoHandleEventAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  SoEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_setEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setEvent" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleEventAction_setEvent" "', argument " "2"" of type '" "SoEvent const *""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  (arg1)->setEvent((SoEvent const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getEvent" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SoEvent *)((SoHandleEventAction const *)arg1)->getEvent();
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setHandled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setHandled" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  (arg1)->setHandled();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_isHandled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_isHandled" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SbBool)((SoHandleEventAction const *)arg1)->isHandled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setGrabber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_setGrabber", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setGrabber" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleEventAction_setGrabber" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setGrabber(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_releaseGrabber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_releaseGrabber" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  (arg1)->releaseGrabber();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getGrabber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getGrabber" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SoNode *)((SoHandleEventAction const *)arg1)->getGrabber();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setPickRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_setPickRoot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setPickRoot" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleEventAction_setPickRoot" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setPickRoot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getPickRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getPickRoot" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SoNode *)((SoHandleEventAction const *)arg1)->getPickRoot();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_setPickRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleEventAction_setPickRadius", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_setPickRadius" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoHandleEventAction_setPickRadius" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setPickRadius(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getPickRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getPickRadius" "', argument " "1"" of type '" "SoHandleEventAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (float)((SoHandleEventAction const *)arg1)->getPickRadius();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getPickedPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getPickedPoint" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SoPickedPoint *)(arg1)->getPickedPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleEventAction_getPickedPointList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleEventAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickedPointList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleEventAction_getPickedPointList" "', argument " "1"" of type '" "SoHandleEventAction *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleEventAction * >(argp1);
  result = (SoPickedPointList *) &(arg1)->getPickedPointList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoHandleEventAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoHandleEventAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoHandleEventAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPickAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_getTypeId" "', argument " "1"" of type '" "SoPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickAction * >(argp1);
  result = ((SoPickAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPickAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoPickAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoPickAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoPickAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_initClass", 0, 0, 0)) SWIG_fail;
  SoPickAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_setViewportRegion" "', argument " "1"" of type '" "SoPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickAction_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_getViewportRegion" "', argument " "1"" of type '" "SoPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickAction * >(argp1);
  result = (SbViewportRegion *) &((SoPickAction const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_enableCulling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickAction_enableCulling", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_enableCulling" "', argument " "1"" of type '" "SoPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoPickAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickAction_enableCulling" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->enableCulling(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickAction_isCullingEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickAction_isCullingEnabled" "', argument " "1"" of type '" "SoPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickAction * >(argp1);
  result = (SbBool)((SoPickAction const *)arg1)->isCullingEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoRayPickAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getTypeId" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = ((SoRayPickAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRayPickAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRayPickAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoRayPickAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRayPickAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoRayPickAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRayPickAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoRayPickAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoRayPickAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoRayPickAction" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoRayPickAction *)new SoRayPickAction((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRayPickAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoRayPickAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoRayPickAction" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_initClass", 0, 0, 0)) SWIG_fail;
  SoRayPickAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_setPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setPoint" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_setPoint" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setPoint" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setPoint((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setNormalizedPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_setNormalizedPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setNormalizedPoint" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_setNormalizedPoint" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setNormalizedPoint" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setNormalizedPoint((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_setRadius", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setRadius" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRayPickAction_setRadius" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setRadius(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getRadius" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (float)((SoRayPickAction const *)arg1)->getRadius();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setRay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setRay" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoRayPickAction_setRay" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoRayPickAction_setRay" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setRay((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setRay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setRay" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoRayPickAction_setRay" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setRay((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setRay__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setRay" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_setRay" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setRay((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setRay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRayPickAction_setRay", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoRayPickAction_setRay__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoRayPickAction_setRay__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoRayPickAction_setRay__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRayPickAction_setRay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRayPickAction::setRay(SbVec3f const &,SbVec3f const &,float,float)\n"
    "    SoRayPickAction::setRay(SbVec3f const &,SbVec3f const &,float)\n"
    "    SoRayPickAction::setRay(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setPickAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_setPickAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setPickAll" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRayPickAction_setPickAll" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setPickAll(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_isPickAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_isPickAll" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SbBool)((SoRayPickAction const *)arg1)->isPickAll();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getPickedPointList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickedPointList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getPickedPointList" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SoPickedPointList *) &((SoRayPickAction const *)arg1)->getPickedPointList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPointList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getPickedPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getPickedPoint" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRayPickAction_getPickedPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPickedPoint *)((SoRayPickAction const *)arg1)->getPickedPoint(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getPickedPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getPickedPoint" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SoPickedPoint *)((SoRayPickAction const *)arg1)->getPickedPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getPickedPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRayPickAction_getPickedPoint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoRayPickAction_getPickedPoint__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoRayPickAction_getPickedPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRayPickAction_getPickedPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRayPickAction::getPickedPoint(int const) const\n"
    "    SoRayPickAction::getPickedPoint() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_computeWorldSpaceRay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_computeWorldSpaceRay" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  (arg1)->computeWorldSpaceRay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_hasWorldSpaceRay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_hasWorldSpaceRay" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SbBool)((SoRayPickAction const *)arg1)->hasWorldSpaceRay();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setObjectSpace__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setObjectSpace" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  (arg1)->setObjectSpace();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setObjectSpace__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_setObjectSpace" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  (arg1)->setObjectSpace((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_setObjectSpace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRayPickAction_setObjectSpace", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoRayPickAction_setObjectSpace__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoRayPickAction_setObjectSpace__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRayPickAction_setObjectSpace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRayPickAction::setObjectSpace()\n"
    "    SoRayPickAction::setObjectSpace(SbMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  SbVec3f *arg6 = 0 ;
  SbBool *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoRayPickAction_intersect" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoRayPickAction_intersect" "', argument " "5"" of type '" "SbVec3f &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "5"" of type '" "SbVec3f &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoRayPickAction_intersect" "', argument " "6"" of type '" "SbVec3f &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "6"" of type '" "SbVec3f &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3f * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoRayPickAction_intersect" "', argument " "7"" of type '" "SbBool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "7"" of type '" "SbBool &""'"); 
  }
  arg7 = reinterpret_cast< SbBool * >(argp7);
  result = (SbBool)((SoRayPickAction const *)arg1)->intersect((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoRayPickAction_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SoRayPickAction const *)arg1)->intersect((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SoRayPickAction const *)arg1)->intersect((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)(arg1)->intersect((SbBox3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)(arg1)->intersect((SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoRayPickAction_intersect" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SbBool)(arg1)->intersect((SbBox3f const &)*arg2,*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_intersect" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbBool)(arg1)->intersect((SbBox3f const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRayPickAction_intersect", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRayPickAction_intersect__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRayPickAction_intersect__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoRayPickAction_intersect__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoRayPickAction_intersect__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoRayPickAction_intersect__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoRayPickAction_intersect__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoRayPickAction_intersect__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRayPickAction_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRayPickAction::intersect(SbVec3f const &,SbVec3f const &,SbVec3f const &,SbVec3f &,SbVec3f &,SbBool &) const\n"
    "    SoRayPickAction::intersect(SbVec3f const &,SbVec3f const &,SbVec3f &) const\n"
    "    SoRayPickAction::intersect(SbVec3f const &) const\n"
    "    SoRayPickAction::intersect(SbBox3f const &,SbBool const)\n"
    "    SoRayPickAction::intersect(SbBox3f const &)\n"
    "    SoRayPickAction::intersect(SbBox3f const &,SbVec3f &,SbBool const)\n"
    "    SoRayPickAction::intersect(SbBox3f const &,SbVec3f &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getViewVolume" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SbViewVolume *) &(arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_getLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbLine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_getLine" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  result = (SbLine *) &(arg1)->getLine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_isBetweenPlanes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRayPickAction_isBetweenPlanes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_isBetweenPlanes" "', argument " "1"" of type '" "SoRayPickAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_isBetweenPlanes" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_isBetweenPlanes" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SoRayPickAction const *)arg1)->isBetweenPlanes((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_addIntersection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_addIntersection" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_addIntersection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_addIntersection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRayPickAction_addIntersection" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoPickedPoint *)(arg1)->addIntersection((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_addIntersection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_addIntersection" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRayPickAction_addIntersection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRayPickAction_addIntersection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SoPickedPoint *)(arg1)->addIntersection((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_addIntersection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRayPickAction_addIntersection", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRayPickAction_addIntersection__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRayPickAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoRayPickAction_addIntersection__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRayPickAction_addIntersection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRayPickAction::addIntersection(SbVec3f const &,SbBool)\n"
    "    SoRayPickAction::addIntersection(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRayPickAction_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRayPickAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRayPickAction_reset" "', argument " "1"" of type '" "SoRayPickAction *""'"); 
  }
  arg1 = reinterpret_cast< SoRayPickAction * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRayPickAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRayPickAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRayPickAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSearchAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getTypeId" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = ((SoSearchAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSearchAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSearchAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSearchAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoSearchAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSearchAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSearchAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoSearchAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_initClass", 0, 0, 0)) SWIG_fail;
  SoSearchAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSearchAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSearchAction", 0, 0, 0)) SWIG_fail;
  result = (SoSearchAction *)new SoSearchAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSearchAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSearchAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSearchAction" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_setNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setNode" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSearchAction_setNode" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getNode" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SoNode *)((SoSearchAction const *)arg1)->getNode();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SoType arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setType" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSearchAction_setType" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSearchAction_setType" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSearchAction_setType" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setType(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setType" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSearchAction_setType" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSearchAction_setType" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSearchAction_setType", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSearchAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSearchAction_setType__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSearchAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSearchAction_setType__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSearchAction_setType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSearchAction::setType(SoType const,SbBool const)\n"
    "    SoSearchAction::setType(SoType const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_getType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getType" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSearchAction_getType" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSearchAction_getType" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  result = ((SoSearchAction const *)arg1)->getType(*arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setName" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  (arg1)->setName(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getName" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = ((SoSearchAction const *)arg1)->getName();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setFind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_setFind", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setFind" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSearchAction_setFind" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFind(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getFind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getFind" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (int)((SoSearchAction const *)arg1)->getFind();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setInterest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SoSearchAction::Interest arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_setInterest", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setInterest" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSearchAction_setInterest" "', argument " "2"" of type '" "SoSearchAction::Interest""'");
  } 
  arg2 = static_cast< SoSearchAction::Interest >(val2);
  (arg1)->setInterest(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getInterest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSearchAction::Interest result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getInterest" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SoSearchAction::Interest)((SoSearchAction const *)arg1)->getInterest();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setSearchingAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_setSearchingAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setSearchingAll" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSearchAction_setSearchingAll" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setSearchingAll(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_isSearchingAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_isSearchingAll" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SbBool)((SoSearchAction const *)arg1)->isSearchingAll();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getPath" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SoPath *)((SoSearchAction const *)arg1)->getPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_getPaths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_getPaths" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SoPathList *) &(arg1)->getPaths();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_reset" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_setFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_setFound" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  (arg1)->setFound();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_isFound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_isFound" "', argument " "1"" of type '" "SoSearchAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  result = (SbBool)((SoSearchAction const *)arg1)->isFound();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_addPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSearchAction *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSearchAction_addPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSearchAction_addPath" "', argument " "1"" of type '" "SoSearchAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSearchAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSearchAction_addPath" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->addPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_SoSearchAction_duringSearchAll_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""SoSearchAction::duringSearchAll""' of type '""SbBool""'");
    }
    SoSearchAction::duringSearchAll = static_cast< SbBool >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SoSearchAction_duringSearchAll_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(SoSearchAction::duringSearchAll));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SoSearchAction_duringSearchAll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SoSearchAction_duringSearchAll_get();
}


SWIGINTERN PyObject *_wrap_SoSearchAction_duringSearchAll_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SoSearchAction_duringSearchAll_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *SoSearchAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSearchAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSearchAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSimplifyAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_getTypeId" "', argument " "1"" of type '" "SoSimplifyAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  result = ((SoSimplifyAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSimplifyAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSimplifyAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSimplifyAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSimplifyAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSimplifyAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoSimplifyAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSimplifyAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSimplifyAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSimplifyAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoSimplifyAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSimplifyAction_initClass", 0, 0, 0)) SWIG_fail;
  SoSimplifyAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSimplifyAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSimplifyAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSimplifyAction", 0, 0, 0)) SWIG_fail;
  result = (SoSimplifyAction *)new SoSimplifyAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSimplifyAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSimplifyAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSimplifyAction" "', argument " "1"" of type '" "SoSimplifyAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_apply" "', argument " "1"" of type '" "SoSimplifyAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_apply" "', argument " "1"" of type '" "SoSimplifyAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_apply" "', argument " "1"" of type '" "SoSimplifyAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSimplifyAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSimplifyAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifyAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSimplifyAction_apply" "', argument " "1"" of type '" "SoSimplifyAction *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifyAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSimplifyAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSimplifyAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSimplifyAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSimplifyAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSimplifyAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSimplifyAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSimplifyAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSimplifyAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSimplifyAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSimplifyAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSimplifyAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSimplifyAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSimplifyAction::apply(SoNode *)\n"
    "    SoSimplifyAction::apply(SoPath *)\n"
    "    SoSimplifyAction::apply(SoPathList const &,SbBool)\n"
    "    SoSimplifyAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *SoSimplifyAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSimplifyAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSimplifyAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoReorganizeAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_getTypeId" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = ((SoReorganizeAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoReorganizeAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoReorganizeAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoReorganizeAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoReorganizeAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoReorganizeAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoReorganizeAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_initClass", 0, 0, 0)) SWIG_fail;
  SoReorganizeAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoReorganizeAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSimplifier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoReorganizeAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSimplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoReorganizeAction" "', argument " "1"" of type '" "SoSimplifier *""'"); 
  }
  arg1 = reinterpret_cast< SoSimplifier * >(argp1);
  result = (SoReorganizeAction *)new SoReorganizeAction(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoReorganizeAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoReorganizeAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoReorganizeAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoReorganizeAction *)new SoReorganizeAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoReorganizeAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoReorganizeAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoReorganizeAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoReorganizeAction__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSimplifier, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoReorganizeAction__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoReorganizeAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoReorganizeAction::SoReorganizeAction(SoSimplifier *)\n"
    "    SoReorganizeAction::SoReorganizeAction()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoReorganizeAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoReorganizeAction" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_getSimplifiedSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSeparator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_getSimplifiedSceneGraph" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SoSeparator *)((SoReorganizeAction const *)arg1)->getSimplifiedSceneGraph();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_generateNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_generateNormals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_generateNormals" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_generateNormals" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->generateNormals(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_areNormalGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_areNormalGenerated" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SbBool)((SoReorganizeAction const *)arg1)->areNormalGenerated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_generateTriangleStrips(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_generateTriangleStrips", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_generateTriangleStrips" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_generateTriangleStrips" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->generateTriangleStrips(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_areTriangleStripGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_areTriangleStripGenerated" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SbBool)((SoReorganizeAction const *)arg1)->areTriangleStripGenerated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_generateTexCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_generateTexCoords", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_generateTexCoords" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_generateTexCoords" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->generateTexCoords(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_areTexCoordsGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_areTexCoordsGenerated" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SbBool)((SoReorganizeAction const *)arg1)->areTexCoordsGenerated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_generateVPNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_generateVPNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_generateVPNodes" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_generateVPNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->generateVPNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_areVPNodesGenerated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_areVPNodesGenerated" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SbBool)(arg1)->areVPNodesGenerated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_matchIndexArrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_matchIndexArrays", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_matchIndexArrays" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoReorganizeAction_matchIndexArrays" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->matchIndexArrays(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_areIndexArraysMatched(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_areIndexArraysMatched" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SbBool)((SoReorganizeAction const *)arg1)->areIndexArraysMatched();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_getSimplifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSimplifier *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_getSimplifier" "', argument " "1"" of type '" "SoReorganizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  result = (SoSimplifier *)((SoReorganizeAction const *)arg1)->getSimplifier();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSimplifier, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_apply" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_apply" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_apply" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoReorganizeAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoReorganizeAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReorganizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_apply" "', argument " "1"" of type '" "SoReorganizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoReorganizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoReorganizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoReorganizeAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoReorganizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoReorganizeAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoReorganizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoReorganizeAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoReorganizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoReorganizeAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoReorganizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoReorganizeAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoReorganizeAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoReorganizeAction::apply(SoNode *)\n"
    "    SoReorganizeAction::apply(SoPath *)\n"
    "    SoReorganizeAction::apply(SoPathList const &,SbBool)\n"
    "    SoReorganizeAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_startReport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReorganizeAction_startReport" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoReorganizeAction::startReport((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReorganizeAction_finishReport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReorganizeAction_finishReport", 0, 0, 0)) SWIG_fail;
  SoReorganizeAction::finishReport();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoReorganizeAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoReorganizeAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoReorganizeAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoWriteAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWriteAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_getTypeId" "', argument " "1"" of type '" "SoWriteAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoWriteAction * >(argp1);
  result = ((SoWriteAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWriteAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoWriteAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWriteAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWriteAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoWriteAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoWriteAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWriteAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWriteAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoWriteAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoWriteAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWriteAction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoWriteAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoWriteAction *)new SoWriteAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoWriteAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWriteAction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoWriteAction *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoWriteAction" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SoWriteAction *)new SoWriteAction(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoWriteAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWriteAction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoWriteAction", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoWriteAction__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoWriteAction__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoWriteAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoWriteAction::SoWriteAction()\n"
    "    SoWriteAction::SoWriteAction(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoWriteAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWriteAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWriteAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoWriteAction" "', argument " "1"" of type '" "SoWriteAction *""'"); 
  }
  arg1 = reinterpret_cast< SoWriteAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWriteAction_initClass", 0, 0, 0)) SWIG_fail;
  SoWriteAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWriteAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_getOutput" "', argument " "1"" of type '" "SoWriteAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoWriteAction * >(argp1);
  result = (SoOutput *)((SoWriteAction const *)arg1)->getOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_continueToApply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoWriteAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_continueToApply" "', argument " "1"" of type '" "SoWriteAction *""'"); 
  }
  arg1 = reinterpret_cast< SoWriteAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWriteAction_continueToApply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->continueToApply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_continueToApply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoWriteAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWriteAction_continueToApply" "', argument " "1"" of type '" "SoWriteAction *""'"); 
  }
  arg1 = reinterpret_cast< SoWriteAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWriteAction_continueToApply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->continueToApply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWriteAction_continueToApply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoWriteAction_continueToApply", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoWriteAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoWriteAction_continueToApply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoWriteAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoWriteAction_continueToApply__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoWriteAction_continueToApply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoWriteAction::continueToApply(SoNode *)\n"
    "    SoWriteAction::continueToApply(SoPath *)\n");
  return 0;
}


SWIGINTERN PyObject *SoWriteAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoWriteAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoWriteAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAudioRenderAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioRenderAction_getTypeId" "', argument " "1"" of type '" "SoAudioRenderAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioRenderAction * >(argp1);
  result = ((SoAudioRenderAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAudioRenderAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAudioRenderAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoAudioRenderAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoAudioRenderAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoAudioRenderAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAudioRenderAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoAudioRenderAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_initClass", 0, 0, 0)) SWIG_fail;
  SoAudioRenderAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioRenderAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAudioRenderAction", 0, 0, 0)) SWIG_fail;
  result = (SoAudioRenderAction *)new SoAudioRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAudioRenderAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioRenderAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoAudioRenderAction" "', argument " "1"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioRenderAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_callDoAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_callDoAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioRenderAction_callDoAction" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAudioRenderAction_callDoAction" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoAudioRenderAction::callDoAction(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioRenderAction_callAudioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioRenderAction_callAudioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioRenderAction_callAudioRender" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAudioRenderAction_callAudioRender" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoAudioRenderAction::callAudioRender(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAudioRenderAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAudioRenderAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAudioRenderAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectingPrimitive_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_path_set" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectingPrimitive_path_set" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  if (arg1) (arg1)->path = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_path_get" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  result = (SoPath *) ((arg1)->path);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  enum SoIntersectingPrimitive::PrimitiveType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectingPrimitive_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_type_set" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectingPrimitive_type_set" "', argument " "2"" of type '" "enum SoIntersectingPrimitive::PrimitiveType""'");
  } 
  arg2 = static_cast< enum SoIntersectingPrimitive::PrimitiveType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  enum SoIntersectingPrimitive::PrimitiveType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_type_get" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  result = (enum SoIntersectingPrimitive::PrimitiveType) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectingPrimitive_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_vertex_set" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectingPrimitive_vertex_set" "', argument " "2"" of type '" "SbVec3f [3]""'"); 
  } 
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(SbVec3f *)&arg1->vertex[ii] = *((SbVec3f *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""vertex""' of type '""SbVec3f [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_vertex_get" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  result = (SbVec3f *)(SbVec3f *) ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_xf_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectingPrimitive_xf_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_xf_vertex_set" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectingPrimitive_xf_vertex_set" "', argument " "2"" of type '" "SbVec3f [3]""'"); 
  } 
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(SbVec3f *)&arg1->xf_vertex[ii] = *((SbVec3f *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""xf_vertex""' of type '""SbVec3f [3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectingPrimitive_xf_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectingPrimitive_xf_vertex_get" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  result = (SbVec3f *)(SbVec3f *) ((arg1)->xf_vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIntersectingPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIntersectingPrimitive", 0, 0, 0)) SWIG_fail;
  result = (SoIntersectingPrimitive *)new SoIntersectingPrimitive();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIntersectingPrimitive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoIntersectingPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectingPrimitive *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectingPrimitive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoIntersectingPrimitive" "', argument " "1"" of type '" "SoIntersectingPrimitive *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectingPrimitive * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIntersectingPrimitive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIntersectingPrimitive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIntersectingPrimitive_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_getTypeId" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  result = ((SoIntersectionDetectionAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIntersectionDetectionAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoIntersectionDetectionAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectionDetectionAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoIntersectionDetectionAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_initClass", 0, 0, 0)) SWIG_fail;
  SoIntersectionDetectionAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIntersectionDetectionAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIntersectionDetectionAction", 0, 0, 0)) SWIG_fail;
  result = (SoIntersectionDetectionAction *)new SoIntersectionDetectionAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIntersectionDetectionAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoIntersectionDetectionAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoIntersectionDetectionAction" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setIntersectionDetectionEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setIntersectionDetectionEpsilon" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectionDetectionAction_setIntersectionDetectionEpsilon" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setIntersectionDetectionEpsilon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_getIntersectionDetectionEpsilon" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  result = (float)((SoIntersectionDetectionAction const *)arg1)->getIntersectionDetectionEpsilon();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setIntersectionEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoIntersectionDetectionAction_setIntersectionEpsilon" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  SoIntersectionDetectionAction::setIntersectionEpsilon(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_getIntersectionEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_getIntersectionEpsilon", 0, 0, 0)) SWIG_fail;
  result = (float)SoIntersectionDetectionAction::getIntersectionEpsilon();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setTypeEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setTypeEnabled", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setTypeEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_setTypeEnabled" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_setTypeEnabled" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoIntersectionDetectionAction_setTypeEnabled" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setTypeEnabled(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isTypeEnabled__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)((SoIntersectionDetectionAction const *)arg1)->isTypeEnabled(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isTypeEnabled__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_isTypeEnabled" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoIntersectionDetectionAction const *)arg1)->isTypeEnabled(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isTypeEnabled(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_isTypeEnabled", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_isTypeEnabled__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_isTypeEnabled__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_isTypeEnabled'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::isTypeEnabled(SoType,SbBool) const\n"
    "    SoIntersectionDetectionAction::isTypeEnabled(SoType) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setManipsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setManipsEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setManipsEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectionDetectionAction_setManipsEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setManipsEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isManipsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_isManipsEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  result = (SbBool)((SoIntersectionDetectionAction const *)arg1)->isManipsEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setDraggersEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setDraggersEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setDraggersEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectionDetectionAction_setDraggersEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDraggersEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isDraggersEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_isDraggersEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  result = (SbBool)((SoIntersectionDetectionAction const *)arg1)->isDraggersEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setShapeInternalsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setShapeInternalsEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setShapeInternalsEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoIntersectionDetectionAction_setShapeInternalsEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setShapeInternalsEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_isShapeInternalsEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_isShapeInternalsEnabled" "', argument " "1"" of type '" "SoIntersectionDetectionAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  result = (SbBool)((SoIntersectionDetectionAction const *)arg1)->isShapeInternalsEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addVisitationCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  SoIntersectionDetectionAction::SoIntersectionVisitationCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "3"" of type '" "SoIntersectionDetectionAction::SoIntersectionVisitationCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addVisitationCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeVisitationCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  SoIntersectionDetectionAction::SoIntersectionVisitationCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "3"" of type '" "SoIntersectionDetectionAction::SoIntersectionVisitationCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->removeVisitationCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::apply(SoNode *)\n"
    "    SoIntersectionDetectionAction::apply(SoPath *)\n"
    "    SoIntersectionDetectionAction::apply(SoPathList const &,SbBool)\n"
    "    SoIntersectionDetectionAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionFilterCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionFilterCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionFilterCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionFilterCB *""'"); 
    }
  }
  (arg1)->setFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addIntersectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionCB *""'"); 
    }
  }
  (arg1)->addIntersectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeIntersectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoIntersectionDetectionAction::SoIntersectionCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "2"" of type '" "SoIntersectionDetectionAction::SoIntersectionCB *""'"); 
    }
  }
  (arg1)->removeIntersectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addVisitationCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_addVisitationCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoIntersectionDetectionAction_addVisitationCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addVisitationCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_addVisitationCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoIntersectionDetectionAction_addVisitationCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoIntersectionDetectionAction_addVisitationCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_addVisitationCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::addVisitationCallback(SoType,SoIntersectionDetectionAction::SoIntersectionVisitationCB *,void *)\n"
    "    SoIntersectionDetectionAction::addVisitationCallback(SoType,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeVisitationCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoIntersectionDetectionAction_removeVisitationCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  SoIntersectionDetectionAction_removeVisitationCallback__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeVisitationCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_removeVisitationCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoIntersectionDetectionAction_removeVisitationCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoIntersectionDetectionAction_removeVisitationCallback__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_removeVisitationCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::removeVisitationCallback(SoType,SoIntersectionDetectionAction::SoIntersectionVisitationCB *,void *)\n"
    "    SoIntersectionDetectionAction::removeVisitationCallback(SoType,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoIntersectionDetectionAction_setFilterCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_setFilterCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoIntersectionDetectionAction_setFilterCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_setFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_setFilterCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_setFilterCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_setFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::setFilterCallback(SoIntersectionDetectionAction::SoIntersectionFilterCB *,void *)\n"
    "    SoIntersectionDetectionAction::setFilterCallback(SoIntersectionDetectionAction::SoIntersectionFilterCB *)\n"
    "    SoIntersectionDetectionAction::setFilterCallback(PyObject *,PyObject *)\n"
    "    SoIntersectionDetectionAction::setFilterCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoIntersectionDetectionAction_addIntersectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_addIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoIntersectionDetectionAction_addIntersectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_addIntersectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_addIntersectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_addIntersectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_addIntersectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::addIntersectionCallback(SoIntersectionDetectionAction::SoIntersectionCB *,void *)\n"
    "    SoIntersectionDetectionAction::addIntersectionCallback(SoIntersectionDetectionAction::SoIntersectionCB *)\n"
    "    SoIntersectionDetectionAction::addIntersectionCallback(PyObject *,PyObject *)\n"
    "    SoIntersectionDetectionAction::addIntersectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIntersectionDetectionAction *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIntersectionDetectionAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIntersectionDetectionAction_removeIntersectionCallback" "', argument " "1"" of type '" "SoIntersectionDetectionAction *""'"); 
  }
  arg1 = reinterpret_cast< SoIntersectionDetectionAction * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIntersectionDetectionAction_removeIntersectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIntersectionDetectionAction_removeIntersectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIntersectionDetectionAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoIntersectionDetectionAction_removeIntersectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIntersectionDetectionAction_removeIntersectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIntersectionDetectionAction::removeIntersectionCallback(SoIntersectionDetectionAction::SoIntersectionCB *,void *)\n"
    "    SoIntersectionDetectionAction::removeIntersectionCallback(SoIntersectionDetectionAction::SoIntersectionCB *)\n"
    "    SoIntersectionDetectionAction::removeIntersectionCallback(PyObject *,PyObject *)\n"
    "    SoIntersectionDetectionAction::removeIntersectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoIntersectionDetectionAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIntersectionDetectionAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIntersectionDetectionAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoToVRMLAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_getTypeId" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = ((SoToVRMLAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoToVRMLAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRMLAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoToVRMLAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoToVRMLAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRMLAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoToVRMLAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_initClass", 0, 0, 0)) SWIG_fail;
  SoToVRMLAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoToVRMLAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoToVRMLAction", 0, 0, 0)) SWIG_fail;
  result = (SoToVRMLAction *)new SoToVRMLAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoToVRMLAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoToVRMLAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoToVRMLAction" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_apply" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_apply" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_apply" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoToVRMLAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_apply" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRMLAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoToVRMLAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRMLAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRMLAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRMLAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRMLAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRMLAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRMLAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRMLAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoToVRMLAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoToVRMLAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoToVRMLAction::apply(SoNode *)\n"
    "    SoToVRMLAction::apply(SoPath *)\n"
    "    SoToVRMLAction::apply(SoPathList const &,SbBool)\n"
    "    SoToVRMLAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_getVRMLSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_getVRMLSceneGraph" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SoNode *)((SoToVRMLAction const *)arg1)->getVRMLSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_expandSoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_expandSoFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_expandSoFile" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_expandSoFile" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->expandSoFile(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_areSoFileExpanded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_areSoFileExpanded" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->areSoFileExpanded();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_setUrlName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbString arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_setUrlName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_setUrlName" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbString,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRMLAction_setUrlName" "', argument " "2"" of type '" "SbString const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRMLAction_setUrlName" "', argument " "2"" of type '" "SbString const""'");
    } else {
      SbString * temp = reinterpret_cast< SbString * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setUrlName(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_getUrlName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_getUrlName" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = ((SoToVRMLAction const *)arg1)->getUrlName();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_writeTexCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_writeTexCoords", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_writeTexCoords" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_writeTexCoords" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->writeTexCoords(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_areTexCoordWritten(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_areTexCoordWritten" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->areTexCoordWritten();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_expandTexture2Node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_expandTexture2Node", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_expandTexture2Node" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_expandTexture2Node" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->expandTexture2Node(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_areTexture2NodeExpanded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_areTexture2NodeExpanded" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->areTexture2NodeExpanded();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_keepUnknownNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_keepUnknownNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_keepUnknownNodes" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_keepUnknownNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->keepUnknownNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_areUnknownNodeKept(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_areUnknownNodeKept" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->areUnknownNodeKept();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_convertInlineNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_convertInlineNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_convertInlineNodes" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_convertInlineNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->convertInlineNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_doConvertInlineNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_doConvertInlineNodes" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->doConvertInlineNodes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_conditionalConversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_conditionalConversion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_conditionalConversion" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_conditionalConversion" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->conditionalConversion(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_doConditionalConversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_doConditionalConversion" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->doConditionalConversion();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_setVerbosity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRMLAction_setVerbosity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_setVerbosity" "', argument " "1"" of type '" "SoToVRMLAction *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRMLAction_setVerbosity" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setVerbosity(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRMLAction_isVerbose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRMLAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRMLAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRMLAction_isVerbose" "', argument " "1"" of type '" "SoToVRMLAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRMLAction * >(argp1);
  result = (SbBool)((SoToVRMLAction const *)arg1)->isVerbose();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoToVRMLAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoToVRMLAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoToVRMLAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoToVRML2Action_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_getTypeId" "', argument " "1"" of type '" "SoToVRML2Action const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  result = ((SoToVRML2Action const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoToVRML2Action::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRML2Action_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoToVRML2Action_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoToVRML2Action::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRML2Action_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRML2Action_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoToVRML2Action::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_initClass", 0, 0, 0)) SWIG_fail;
  SoToVRML2Action::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoToVRML2Action(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoToVRML2Action", 0, 0, 0)) SWIG_fail;
  result = (SoToVRML2Action *)new SoToVRML2Action();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoToVRML2Action, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoToVRML2Action(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoToVRML2Action" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_apply" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_apply" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_apply" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoToVRML2Action_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_apply" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoToVRML2Action_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoToVRML2Action_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRML2Action, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRML2Action_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRML2Action, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRML2Action_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRML2Action, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoToVRML2Action_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoToVRML2Action, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoToVRML2Action_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoToVRML2Action_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoToVRML2Action::apply(SoNode *)\n"
    "    SoToVRML2Action::apply(SoPath *)\n"
    "    SoToVRML2Action::apply(SoPathList const &,SbBool)\n"
    "    SoToVRML2Action::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_getVRML2SceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVRMLGroup *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_getVRML2SceneGraph" "', argument " "1"" of type '" "SoToVRML2Action const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  result = (SoVRMLGroup *)((SoToVRML2Action const *)arg1)->getVRML2SceneGraph();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_reuseAppearanceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_reuseAppearanceNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_reuseAppearanceNodes" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRML2Action_reuseAppearanceNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->reuseAppearanceNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_doReuseAppearanceNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_doReuseAppearanceNodes" "', argument " "1"" of type '" "SoToVRML2Action const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  result = (SbBool)((SoToVRML2Action const *)arg1)->doReuseAppearanceNodes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_reusePropertyNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_reusePropertyNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_reusePropertyNodes" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRML2Action_reusePropertyNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->reusePropertyNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_doReusePropertyNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_doReusePropertyNodes" "', argument " "1"" of type '" "SoToVRML2Action const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  result = (SbBool)((SoToVRML2Action const *)arg1)->doReusePropertyNodes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_reuseGeometryNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoToVRML2Action_reuseGeometryNodes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_reuseGeometryNodes" "', argument " "1"" of type '" "SoToVRML2Action *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoToVRML2Action_reuseGeometryNodes" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->reuseGeometryNodes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoToVRML2Action_doReuseGeometryNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoToVRML2Action *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoToVRML2Action, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoToVRML2Action_doReuseGeometryNodes" "', argument " "1"" of type '" "SoToVRML2Action const *""'"); 
  }
  arg1 = reinterpret_cast< SoToVRML2Action * >(argp1);
  result = (SbBool)((SoToVRML2Action const *)arg1)->doReuseGeometryNodes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoToVRML2Action_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoToVRML2Action, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoToVRML2Action_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoHardCopy_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHardCopy_init", 0, 0, 0)) SWIG_fail;
  SoHardCopy::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHardCopy_getProductName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHardCopy_getProductName", 0, 0, 0)) SWIG_fail;
  result = (char *)SoHardCopy::getProductName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHardCopy_getVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHardCopy_getVersion", 0, 0, 0)) SWIG_fail;
  result = (char *)SoHardCopy::getVersion();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoHardCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHardCopy *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoHardCopy", 0, 0, 0)) SWIG_fail;
  result = (SoHardCopy *)new SoHardCopy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHardCopy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoHardCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHardCopy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHardCopy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoHardCopy" "', argument " "1"" of type '" "SoHardCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoHardCopy * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoHardCopy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoHardCopy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoHardCopy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoVectorOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVectorOutput", 0, 0, 0)) SWIG_fail;
  result = (SoVectorOutput *)new SoVectorOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVectorOutput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoVectorOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoVectorOutput" "', argument " "1"" of type '" "SoVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorOutput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorOutput_openFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorOutput *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorOutput_openFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorOutput_openFile" "', argument " "1"" of type '" "SoVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorOutput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorOutput_openFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->openFile((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorOutput_closeFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorOutput_closeFile" "', argument " "1"" of type '" "SoVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorOutput * >(argp1);
  (arg1)->closeFile();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorOutput_getFilePointer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorOutput_getFilePointer" "', argument " "1"" of type '" "SoVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorOutput * >(argp1);
  result = (FILE *)(arg1)->getFilePointer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVectorOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVectorOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVectorOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPSVectorOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPSVectorOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPSVectorOutput", 0, 0, 0)) SWIG_fail;
  result = (SoPSVectorOutput *)new SoPSVectorOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPSVectorOutput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoPSVectorOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPSVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPSVectorOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPSVectorOutput" "', argument " "1"" of type '" "SoPSVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoPSVectorOutput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPSVectorOutput_setColored__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPSVectorOutput *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPSVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPSVectorOutput_setColored" "', argument " "1"" of type '" "SoPSVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoPSVectorOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPSVectorOutput_setColored" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setColored(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPSVectorOutput_setColored__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPSVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPSVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPSVectorOutput_setColored" "', argument " "1"" of type '" "SoPSVectorOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoPSVectorOutput * >(argp1);
  (arg1)->setColored();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPSVectorOutput_setColored(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPSVectorOutput_setColored", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPSVectorOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPSVectorOutput_setColored__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPSVectorOutput, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPSVectorOutput_setColored__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPSVectorOutput_setColored'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPSVectorOutput::setColored(SbBool)\n"
    "    SoPSVectorOutput::setColored()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPSVectorOutput_getColored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPSVectorOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPSVectorOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPSVectorOutput_getColored" "', argument " "1"" of type '" "SoPSVectorOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoPSVectorOutput * >(argp1);
  result = (SbBool)((SoPSVectorOutput const *)arg1)->getColored();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPSVectorOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPSVectorOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPSVectorOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVectorizeAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getTypeId" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = ((SoVectorizeAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVectorizeAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVectorizeAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoVectorizeAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoVectorizeAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoVectorizeAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoVectorizeAction" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getOutput" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorOutput *)((SoVectorizeAction const *)arg1)->getOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVectorOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_initClass", 0, 0, 0)) SWIG_fail;
  SoVectorizeAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_apply__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_apply" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_apply__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_apply" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->apply(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_apply__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_apply" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_apply" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->apply((SoPathList const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_apply__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_apply" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoPathList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_apply" "', argument " "2"" of type '" "SoPathList const &""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->apply((SoPathList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_apply(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_apply", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_apply__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_apply__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_apply__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoPathList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_apply__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_apply'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::apply(SoNode *)\n"
    "    SoVectorizeAction::apply(SoPath *)\n"
    "    SoVectorizeAction::apply(SoPathList const &,SbBool)\n"
    "    SoVectorizeAction::apply(SoPathList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginStandardPage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::PageSize *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  SoVectorizeAction::PageSize temp2 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginStandardPage" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_beginStandardPage" "', argument " "2"" of type '" "SoVectorizeAction::PageSize const &""'");
  } else {
    temp2 = static_cast< SoVectorizeAction::PageSize >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_beginStandardPage" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->beginStandardPage((SoVectorizeAction::PageSize const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginStandardPage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::PageSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  SoVectorizeAction::PageSize temp2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginStandardPage" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_beginStandardPage" "', argument " "2"" of type '" "SoVectorizeAction::PageSize const &""'");
  } else {
    temp2 = static_cast< SoVectorizeAction::PageSize >(val2);
    arg2 = &temp2;
  }
  (arg1)->beginStandardPage((SoVectorizeAction::PageSize const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginStandardPage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_beginStandardPage", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_beginStandardPage__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_beginStandardPage__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_beginStandardPage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::beginStandardPage(SoVectorizeAction::PageSize const &,float const)\n"
    "    SoVectorizeAction::beginStandardPage(SoVectorizeAction::PageSize const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginPage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  SoVectorizeAction::DimensionUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginPage" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_beginPage" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginPage" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_beginPage" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginPage" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVectorizeAction_beginPage" "', argument " "4"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg4 = static_cast< SoVectorizeAction::DimensionUnit >(val4);
  (arg1)->beginPage((SbVec2f const &)*arg2,(SbVec2f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginPage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginPage" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_beginPage" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginPage" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_beginPage" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginPage" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->beginPage((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginPage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_beginPage", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_beginPage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoVectorizeAction_beginPage__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_beginPage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::beginPage(SbVec2f const &,SbVec2f const &,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::beginPage(SbVec2f const &,SbVec2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_endPage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_endPage" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  (arg1)->endPage();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_calibrate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_calibrate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_calibrate" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_calibrate" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_calibrate" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->calibrate((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginViewport__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  SoVectorizeAction::DimensionUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginViewport" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_beginViewport" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginViewport" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVectorizeAction_beginViewport" "', argument " "4"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg4 = static_cast< SoVectorizeAction::DimensionUnit >(val4);
  (arg1)->beginViewport((SbVec2f const &)*arg2,(SbVec2f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginViewport__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginViewport" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_beginViewport" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginViewport" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->beginViewport((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginViewport__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginViewport" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_beginViewport" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->beginViewport((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginViewport__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_beginViewport" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  (arg1)->beginViewport();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_beginViewport(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_beginViewport", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoVectorizeAction_beginViewport__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_beginViewport__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_beginViewport__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoVectorizeAction_beginViewport__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_beginViewport'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::beginViewport(SbVec2f const &,SbVec2f const &,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::beginViewport(SbVec2f const &,SbVec2f const &)\n"
    "    SoVectorizeAction::beginViewport(SbVec2f const &)\n"
    "    SoVectorizeAction::beginViewport()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_endViewport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_endViewport" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  (arg1)->endViewport();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setOrientation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::Orientation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setOrientation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setOrientation" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setOrientation" "', argument " "2"" of type '" "SoVectorizeAction::Orientation""'");
  } 
  arg2 = static_cast< SoVectorizeAction::Orientation >(val2);
  (arg1)->setOrientation(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getOrientation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::Orientation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getOrientation" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::Orientation)((SoVectorizeAction const *)arg1)->getOrientation();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBackgroundColor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbBool arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  (arg1)->setBackgroundColor(arg2,(SbColor const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBackgroundColor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setBackgroundColor" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setBackgroundColor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBackgroundColor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setBackgroundColor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_setBackgroundColor__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_setBackgroundColor__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setBackgroundColor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setBackgroundColor(SbBool,SbColor const &)\n"
    "    SoVectorizeAction::setBackgroundColor(SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getBackgroundColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getBackgroundColor" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_getBackgroundColor" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_getBackgroundColor" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = (SbBool)((SoVectorizeAction const *)arg1)->getBackgroundColor(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setNominalWidth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  SoVectorizeAction::DimensionUnit arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setNominalWidth" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setNominalWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setNominalWidth" "', argument " "3"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg3 = static_cast< SoVectorizeAction::DimensionUnit >(val3);
  (arg1)->setNominalWidth(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setNominalWidth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setNominalWidth" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setNominalWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setNominalWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setNominalWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setNominalWidth", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_setNominalWidth__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setNominalWidth__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setNominalWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setNominalWidth(float,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setNominalWidth(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getNominalWidth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::DimensionUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getNominalWidth" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_getNominalWidth" "', argument " "2"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg2 = static_cast< SoVectorizeAction::DimensionUnit >(val2);
  result = (float)((SoVectorizeAction const *)arg1)->getNominalWidth(arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getNominalWidth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getNominalWidth" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (float)((SoVectorizeAction const *)arg1)->getNominalWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getNominalWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getNominalWidth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoVectorizeAction_getNominalWidth__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_getNominalWidth__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_getNominalWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::getNominalWidth(SoVectorizeAction::DimensionUnit) const\n"
    "    SoVectorizeAction::getNominalWidth() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPixelImageSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  SoVectorizeAction::DimensionUnit arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPixelImageSize" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPixelImageSize" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setPixelImageSize" "', argument " "3"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg3 = static_cast< SoVectorizeAction::DimensionUnit >(val3);
  (arg1)->setPixelImageSize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPixelImageSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPixelImageSize" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPixelImageSize" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setPixelImageSize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPixelImageSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setPixelImageSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_setPixelImageSize__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setPixelImageSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setPixelImageSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setPixelImageSize(float,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setPixelImageSize(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPixelImageSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::DimensionUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPixelImageSize" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_getPixelImageSize" "', argument " "2"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg2 = static_cast< SoVectorizeAction::DimensionUnit >(val2);
  result = (float)((SoVectorizeAction const *)arg1)->getPixelImageSize(arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPixelImageSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPixelImageSize" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (float)((SoVectorizeAction const *)arg1)->getPixelImageSize();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPixelImageSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getPixelImageSize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoVectorizeAction_getPixelImageSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_getPixelImageSize__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_getPixelImageSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::getPixelImageSize(SoVectorizeAction::DimensionUnit) const\n"
    "    SoVectorizeAction::getPixelImageSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPointStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::PointStyle *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  SoVectorizeAction::PointStyle temp2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setPointStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPointStyle" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPointStyle" "', argument " "2"" of type '" "SoVectorizeAction::PointStyle const &""'");
  } else {
    temp2 = static_cast< SoVectorizeAction::PointStyle >(val2);
    arg2 = &temp2;
  }
  (arg1)->setPointStyle((SoVectorizeAction::PointStyle const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPointStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::PointStyle result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPointStyle" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::PointStyle)((SoVectorizeAction const *)arg1)->getPointStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPageStartpos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPageStartpos" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SbVec2f *) &((SoVectorizeAction const *)arg1)->getPageStartpos();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPageSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPageSize" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SbVec2f *) &((SoVectorizeAction const *)arg1)->getPageSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setDrawingDimensions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SoVectorizeAction::DimensionUnit arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "3"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg3 = static_cast< SoVectorizeAction::DimensionUnit >(val3);
  (arg1)->setDrawingDimensions((SbVec2f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setDrawingDimensions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setDrawingDimensions((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setDrawingDimensions__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  SoVectorizeAction::DimensionUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "4"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg4 = static_cast< SoVectorizeAction::DimensionUnit >(val4);
  (arg1)->setDrawingDimensions(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setDrawingDimensions__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setDrawingDimensions" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDrawingDimensions(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setDrawingDimensions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setDrawingDimensions", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_setDrawingDimensions__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setDrawingDimensions__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setDrawingDimensions__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoVectorizeAction_setDrawingDimensions__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setDrawingDimensions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setDrawingDimensions(SbVec2f const &,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setDrawingDimensions(SbVec2f const &)\n"
    "    SoVectorizeAction::setDrawingDimensions(float,float,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setDrawingDimensions(float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getDrawingDimensions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::DimensionUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_getDrawingDimensions" "', argument " "2"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg2 = static_cast< SoVectorizeAction::DimensionUnit >(val2);
  result = ((SoVectorizeAction const *)arg1)->getDrawingDimensions(arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getDrawingDimensions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getDrawingDimensions" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = ((SoVectorizeAction const *)arg1)->getDrawingDimensions();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getDrawingDimensions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getDrawingDimensions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoVectorizeAction_getDrawingDimensions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_getDrawingDimensions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_getDrawingDimensions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::getDrawingDimensions(SoVectorizeAction::DimensionUnit) const\n"
    "    SoVectorizeAction::getDrawingDimensions() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setStartPosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SoVectorizeAction::DimensionUnit arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "3"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg3 = static_cast< SoVectorizeAction::DimensionUnit >(val3);
  (arg1)->setStartPosition((SbVec2f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setStartPosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setStartPosition((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setStartPosition__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  SoVectorizeAction::DimensionUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "4"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg4 = static_cast< SoVectorizeAction::DimensionUnit >(val4);
  (arg1)->setStartPosition(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setStartPosition__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVectorizeAction_setStartPosition" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setStartPosition(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setStartPosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setStartPosition", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVectorizeAction_setStartPosition__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setStartPosition__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVectorizeAction_setStartPosition__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoVectorizeAction_setStartPosition__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setStartPosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setStartPosition(SbVec2f const &,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setStartPosition(SbVec2f const &)\n"
    "    SoVectorizeAction::setStartPosition(float,float,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setStartPosition(float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getStartPosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::DimensionUnit arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getStartPosition" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_getStartPosition" "', argument " "2"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg2 = static_cast< SoVectorizeAction::DimensionUnit >(val2);
  result = ((SoVectorizeAction const *)arg1)->getStartPosition(arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getStartPosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getStartPosition" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = ((SoVectorizeAction const *)arg1)->getStartPosition();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getStartPosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getStartPosition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoVectorizeAction_getStartPosition__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_getStartPosition__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_getStartPosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::getStartPosition(SoVectorizeAction::DimensionUnit) const\n"
    "    SoVectorizeAction::getStartPosition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setColorTranslationMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::ColorTranslationMethod arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setColorTranslationMethod", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setColorTranslationMethod" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setColorTranslationMethod" "', argument " "2"" of type '" "SoVectorizeAction::ColorTranslationMethod""'");
  } 
  arg2 = static_cast< SoVectorizeAction::ColorTranslationMethod >(val2);
  (arg1)->setColorTranslationMethod(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getColorTranslationMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::ColorTranslationMethod result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getColorTranslationMethod" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::ColorTranslationMethod)((SoVectorizeAction const *)arg1)->getColorTranslationMethod();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setLineEndStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::EndLineStyle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setLineEndStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setLineEndStyle" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setLineEndStyle" "', argument " "2"" of type '" "SoVectorizeAction::EndLineStyle""'");
  } 
  arg2 = static_cast< SoVectorizeAction::EndLineStyle >(val2);
  (arg1)->setLineEndStyle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getLineEndStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::EndLineStyle result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getLineEndStyle" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::EndLineStyle)((SoVectorizeAction const *)arg1)->getLineEndStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setLineJoinsStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::JoinLineStyle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setLineJoinsStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setLineJoinsStyle" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setLineJoinsStyle" "', argument " "2"" of type '" "SoVectorizeAction::JoinLineStyle""'");
  } 
  arg2 = static_cast< SoVectorizeAction::JoinLineStyle >(val2);
  (arg1)->setLineJoinsStyle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getLineJoinsStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::JoinLineStyle result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getLineJoinsStyle" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::JoinLineStyle)((SoVectorizeAction const *)arg1)->getLineJoinsStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setHLHSRMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SoVectorizeAction::HLHSRMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setHLHSRMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setHLHSRMode" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setHLHSRMode" "', argument " "2"" of type '" "SoVectorizeAction::HLHSRMode""'");
  } 
  arg2 = static_cast< SoVectorizeAction::HLHSRMode >(val2);
  (arg1)->setHLHSRMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getHLHSRMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVectorizeAction::HLHSRMode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getHLHSRMode" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SoVectorizeAction::HLHSRMode)((SoVectorizeAction const *)arg1)->getHLHSRMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBorder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setBorder" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setBorder" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setBorder(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBorder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  SbColor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setBorder" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setBorder" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_setBorder" "', argument " "3"" of type '" "SbColor""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizeAction_setBorder" "', argument " "3"" of type '" "SbColor""'");
    } else {
      SbColor * temp = reinterpret_cast< SbColor * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setBorder(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setBorder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setBorder", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_setBorder__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_setBorder__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setBorder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setBorder(float)\n"
    "    SoVectorizeAction::setBorder(float,SbColor)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setMiterLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setMiterLimit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setMiterLimit" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setMiterLimit" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setMiterLimit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getMiterLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getMiterLimit" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (float)((SoVectorizeAction const *)arg1)->getMiterLimit();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPenDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  float *arg4 = 0 ;
  SoVectorizeAction::DimensionUnit arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "3"" of type '" "SbColor const *""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "4"" of type '" "float const *""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "5"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg5 = static_cast< SoVectorizeAction::DimensionUnit >(val5);
  (arg1)->setPenDescription(arg2,(SbColor const *)arg3,(float const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPenDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "3"" of type '" "SbColor const *""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "4"" of type '" "float const *""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  (arg1)->setPenDescription(arg2,(SbColor const *)arg3,(float const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPenDescription__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "3"" of type '" "SbColor const *""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  (arg1)->setPenDescription(arg2,(SbColor const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPenDescription__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setPenDescription" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPenDescription(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setPenDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setPenDescription", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVectorizeAction_setPenDescription__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_setPenDescription__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoVectorizeAction_setPenDescription__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoVectorizeAction_setPenDescription__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_setPenDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::setPenDescription(int,SbColor const *,float const *,SoVectorizeAction::DimensionUnit)\n"
    "    SoVectorizeAction::setPenDescription(int,SbColor const *,float const *)\n"
    "    SoVectorizeAction::setPenDescription(int,SbColor const *)\n"
    "    SoVectorizeAction::setPenDescription(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPenDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  float *arg3 = 0 ;
  SoVectorizeAction::DimensionUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "2"" of type '" "SbColor *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "3"" of type '" "float *""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "4"" of type '" "SoVectorizeAction::DimensionUnit""'");
  } 
  arg4 = static_cast< SoVectorizeAction::DimensionUnit >(val4);
  ((SoVectorizeAction const *)arg1)->getPenDescription(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPenDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "2"" of type '" "SbColor *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVectorizeAction_getPenDescription" "', argument " "3"" of type '" "float *""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ((SoVectorizeAction const *)arg1)->getPenDescription(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPenDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVectorizeAction_getPenDescription", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbColor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVectorizeAction_getPenDescription__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVectorizeAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbColor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoVectorizeAction_getPenDescription__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVectorizeAction_getPenDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVectorizeAction::getPenDescription(SbColor *,float *,SoVectorizeAction::DimensionUnit) const\n"
    "    SoVectorizeAction::getPenDescription(SbColor *,float *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getPenNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getPenNum" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (int)((SoVectorizeAction const *)arg1)->getPenNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_setColorPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_setColorPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_setColorPriority" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_setColorPriority" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setColorPriority(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_getColorPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_getColorPriority" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SbBool)((SoVectorizeAction const *)arg1)->getColorPriority();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_enableLighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizeAction_enableLighting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_enableLighting" "', argument " "1"" of type '" "SoVectorizeAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizeAction_enableLighting" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->enableLighting(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizeAction_isLightingEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizeAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizeAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizeAction_isLightingEnabled" "', argument " "1"" of type '" "SoVectorizeAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizeAction * >(argp1);
  result = (SbBool)((SoVectorizeAction const *)arg1)->isLightingEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVectorizeAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVectorizeAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMultiTextureCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoMultiTextureCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMultiTextureCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoMultiTextureCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_init" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_setDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_setDefault" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_setDefault" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_setDefault" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureCoordinateElement::setDefault(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_setDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_setDefault" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_setDefault" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureCoordinateElement::setDefault(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_setDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_setDefault", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_setDefault__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureCoordinateElement_setDefault__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_setDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::setDefault(SoState *const,SoNode *const,int const)\n"
    "    SoMultiTextureCoordinateElement::setDefault(SoState *const,SoNode *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  int32_t arg4 ;
  SbVec2f *arg5 = (SbVec2f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "5"" of type '" "SbVec2f const *const""'"); 
  }
  arg5 = reinterpret_cast< SbVec2f * >(argp5);
  SoMultiTextureCoordinateElement::set2(arg1,arg2,arg3,arg4,(SbVec2f const *)arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  int32_t arg4 ;
  SbVec3f *arg5 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "5"" of type '" "SbVec3f const *const""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  SoMultiTextureCoordinateElement::set3(arg1,arg2,arg3,arg4,(SbVec3f const *)arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set4__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  int32_t arg4 ;
  SbVec4f *arg5 = (SbVec4f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "5"" of type '" "SbVec4f const *const""'"); 
  }
  arg5 = reinterpret_cast< SbVec4f * >(argp5);
  SoMultiTextureCoordinateElement::set4(arg1,arg2,arg3,arg4,(SbVec4f const *)arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureCoordinateElement::CoordType)SoMultiTextureCoordinateElement::getType(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureCoordinateElement::CoordType)SoMultiTextureCoordinateElement::getType(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getType__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureCoordinateElement::CoordType)((SoMultiTextureCoordinateElement const *)arg1)->getType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getType__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SoMultiTextureCoordinateElement::CoordType)((SoMultiTextureCoordinateElement const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getType__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getType__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getType__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getType(SoState *const,int const)\n"
    "    SoMultiTextureCoordinateElement::getType(SoState *const)\n"
    "    SoMultiTextureCoordinateElement::getType(int const) const\n"
    "    SoMultiTextureCoordinateElement::getType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMultiTextureCoordinateElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureCoordinateElement *)SoMultiTextureCoordinateElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbVec4f *) &((SoMultiTextureCoordinateElement const *)arg1)->get(arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getNum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getNum" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int32_t)((SoMultiTextureCoordinateElement const *)arg1)->getNum(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getNum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getNum" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (int32_t)((SoMultiTextureCoordinateElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getNum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getNum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getNum__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getNum__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getNum(int const) const\n"
    "    SoMultiTextureCoordinateElement::getNum() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_is2D__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_is2D" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_is2D" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoMultiTextureCoordinateElement const *)arg1)->is2D(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_is2D__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_is2D" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SbBool)((SoMultiTextureCoordinateElement const *)arg1)->is2D();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_is2D(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_is2D", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_is2D__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_is2D__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_is2D'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::is2D(int const) const\n"
    "    SoMultiTextureCoordinateElement::is2D() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getDimension__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getDimension" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getDimension" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int32_t)((SoMultiTextureCoordinateElement const *)arg1)->getDimension(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getDimension__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getDimension" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (int32_t)((SoMultiTextureCoordinateElement const *)arg1)->getDimension();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getDimension(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getDimension", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getDimension__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getDimension__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getDimension'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getDimension(int const) const\n"
    "    SoMultiTextureCoordinateElement::getDimension() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get2" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_get2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec2f *) &((SoMultiTextureCoordinateElement const *)arg1)->get2(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get3" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_get3" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec3f *) &((SoMultiTextureCoordinateElement const *)arg1)->get3(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get4__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get4" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_get4" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec4f *) &((SoMultiTextureCoordinateElement const *)arg1)->get4(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr2" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr2(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr2" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SbVec2f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getArrayPtr2", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getArrayPtr2__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getArrayPtr2__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getArrayPtr2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr2(int const) const\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr3" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr3" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SbVec3f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getArrayPtr3", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getArrayPtr3__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getArrayPtr3__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getArrayPtr3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr3(int const) const\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr3() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr4__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr4" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr4(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr4__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_getArrayPtr4" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SbVec4f *)((SoMultiTextureCoordinateElement const *)arg1)->getArrayPtr4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_getArrayPtr4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_getArrayPtr4", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureCoordinateElement_getArrayPtr4__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_getArrayPtr4__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_getArrayPtr4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr4(int const) const\n"
    "    SoMultiTextureCoordinateElement::getArrayPtr4() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_push" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_matches" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoMultiTextureCoordinateElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_copyMatchInfo" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  result = (SoElement *)((SoMultiTextureCoordinateElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureCoordinateElement_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbVec4f *) &((SoMultiTextureCoordinateElement const *)arg1)->get((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_get", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMultiTextureCoordinateElement_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureCoordinateElement_get__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::get(int const,SbVec3f const &,SbVec3f const &) const\n"
    "    SoMultiTextureCoordinateElement::get(SbVec3f const &,SbVec3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec2f *arg4 = (SbVec2f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureCoordinateElement_set2" "', argument " "4"" of type '" "SbVec2f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  SoMultiTextureCoordinateElement::set2(arg1,arg2,arg3,(SbVec2f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_set2", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureCoordinateElement_set2__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbVec2f, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoMultiTextureCoordinateElement_set2__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_set2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::set2(SoState *const,SoNode *const,int const,int32_t const,SbVec2f const *const)\n"
    "    SoMultiTextureCoordinateElement::set2(SoState *const,SoNode *const,int32_t const,SbVec2f const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec3f *arg4 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureCoordinateElement_set3" "', argument " "4"" of type '" "SbVec3f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  SoMultiTextureCoordinateElement::set3(arg1,arg2,arg3,(SbVec3f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_set3", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureCoordinateElement_set3__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbVec3f, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoMultiTextureCoordinateElement_set3__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_set3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::set3(SoState *const,SoNode *const,int const,int32_t const,SbVec3f const *const)\n"
    "    SoMultiTextureCoordinateElement::set3(SoState *const,SoNode *const,int32_t const,SbVec3f const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set4__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec4f *arg4 = (SbVec4f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMultiTextureCoordinateElement_set4" "', argument " "4"" of type '" "SbVec4f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec4f * >(argp4);
  SoMultiTextureCoordinateElement::set4(arg1,arg2,arg3,(SbVec4f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_set4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_set4", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMultiTextureCoordinateElement_set4__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbVec4f, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoMultiTextureCoordinateElement_set4__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_set4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::set4(SoState *const,SoNode *const,int const,int32_t const,SbVec4f const *const)\n"
    "    SoMultiTextureCoordinateElement::set4(SoState *const,SoNode *const,int32_t const,SbVec4f const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get2" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &((SoMultiTextureCoordinateElement const *)arg1)->get2(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_get2", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_get2__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureCoordinateElement_get2__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_get2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::get2(int const,int const) const\n"
    "    SoMultiTextureCoordinateElement::get2(int const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get3" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoMultiTextureCoordinateElement const *)arg1)->get3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_get3", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_get3__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureCoordinateElement_get3__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_get3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::get3(int const,int const) const\n"
    "    SoMultiTextureCoordinateElement::get3(int const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get4__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureCoordinateElement_get4" "', argument " "1"" of type '" "SoMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureCoordinateElement_get4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &((SoMultiTextureCoordinateElement const *)arg1)->get4(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureCoordinateElement_get4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureCoordinateElement_get4", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureCoordinateElement_get4__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureCoordinateElement_get4__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureCoordinateElement_get4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureCoordinateElement::get4(int const,int const) const\n"
    "    SoMultiTextureCoordinateElement::get4(int const) const\n");
  return 0;
}


SWIGINTERN PyObject *SoMultiTextureCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMultiTextureCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getTypeId" "', argument " "1"" of type '" "SoShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  result = ((SoShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_initClass", 0, 0, 0)) SWIG_fail;
  SoShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_affectsState" "', argument " "1"" of type '" "SoShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  result = (SbBool)((SoShape const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_notify" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getBoundingBox" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_GLRender" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_rayPick" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_callback" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_computeBBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SbBox3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_computeBBox", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_computeBBox" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_computeBBox" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbBox3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShape_computeBBox" "', argument " "3"" of type '" "SbBox3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShape_computeBBox" "', argument " "3"" of type '" "SbBox3f &""'"); 
  }
  arg3 = reinterpret_cast< SbBox3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoShape_computeBBox" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShape_computeBBox" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  (arg1)->computeBBox(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getPrimitiveCount" "', argument " "1"" of type '" "SoShape *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getScreenSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBox3f *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_getScreenSize", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getScreenSize" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShape_getScreenSize" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShape_getScreenSize" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShape_getScreenSize" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoShape_getScreenSize" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  SoShape::getScreenSize(arg1,(SbBox3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getDecimatedComplexity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShape_getDecimatedComplexity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getDecimatedComplexity" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShape_getDecimatedComplexity" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (float)SoShape::getDecimatedComplexity(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShape_getBoundingBoxCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBoundingBoxCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShape_getBoundingBoxCache" "', argument " "1"" of type '" "SoShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoShape * >(argp1);
  result = (SoBoundingBoxCache *)((SoShape const *)arg1)->getBoundingBoxCache();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoImage_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoImage::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_getTypeId" "', argument " "1"" of type '" "SoImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = ((SoImage const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_initClass", 0, 0, 0)) SWIG_fail;
  SoImage::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoImage", 0, 0, 0)) SWIG_fail;
  result = (SoImage *)new SoImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoImage, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_width_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_width_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->width = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_width_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->width);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_height_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_height_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_height_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_vertAlignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_vertAlignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_vertAlignment_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_vertAlignment_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->vertAlignment = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_vertAlignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_vertAlignment_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFEnum *)& ((arg1)->vertAlignment);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_horAlignment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_horAlignment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_horAlignment_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_horAlignment_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->horAlignment = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_horAlignment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_horAlignment_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFEnum *)& ((arg1)->horAlignment);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_image_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_image_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->image = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_image_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFImage *)& ((arg1)->image);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_filename_set" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_filename_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->filename = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_filename_get" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  result = (SoSFString *)& ((arg1)->filename);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_GLRender" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_rayPick" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoImage_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoImage *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoImage_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoImage_getPrimitiveCount" "', argument " "1"" of type '" "SoImage *""'"); 
  }
  arg1 = reinterpret_cast< SoImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoImage_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoImage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVectorizePSAction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_getTypeId" "', argument " "1"" of type '" "SoVectorizePSAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  result = ((SoVectorizePSAction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVectorizePSAction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_addMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  SoActionMethod arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_addMethod", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_addMethod" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizePSAction_addMethod" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_SoAction_p_SoNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVectorizePSAction_addMethod" "', argument " "2"" of type '" "SoActionMethod""'"); 
    }
  }
  SoVectorizePSAction::addMethod(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_enableElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_enableElement", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_enableElement" "', argument " "1"" of type '" "SoType const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVectorizePSAction_enableElement" "', argument " "1"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizePSAction_enableElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoVectorizePSAction::enableElement(SWIG_STD_MOVE(arg1),arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVectorizePSAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVectorizePSAction", 0, 0, 0)) SWIG_fail;
  result = (SoVectorizePSAction *)new SoVectorizePSAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVectorizePSAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoVectorizePSAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoVectorizePSAction" "', argument " "1"" of type '" "SoVectorizePSAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_initClass", 0, 0, 0)) SWIG_fail;
  SoVectorizePSAction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_setDefault2DFont(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_setDefault2DFont", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_setDefault2DFont" "', argument " "1"" of type '" "SoVectorizePSAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setDefault2DFont((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_getDefault2DFont(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_getDefault2DFont" "', argument " "1"" of type '" "SoVectorizePSAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  result = (SbString *) &((SoVectorizePSAction const *)arg1)->getDefault2DFont();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_setGouraudThreshold(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVectorizePSAction_setGouraudThreshold", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_setGouraudThreshold" "', argument " "1"" of type '" "SoVectorizePSAction *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVectorizePSAction_setGouraudThreshold" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setGouraudThreshold(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPSVectorOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_getOutput" "', argument " "1"" of type '" "SoVectorizePSAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  result = (SoPSVectorOutput *)((SoVectorizePSAction const *)arg1)->getOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPSVectorOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVectorizePSAction_getPSOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVectorizePSAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPSVectorOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVectorizePSAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVectorizePSAction_getPSOutput" "', argument " "1"" of type '" "SoVectorizePSAction const *""'"); 
  }
  arg1 = reinterpret_cast< SoVectorizePSAction * >(argp1);
  result = (SoPSVectorOutput *)((SoVectorizePSAction const *)arg1)->getPSOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPSVectorOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVectorizePSAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVectorizePSAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVectorizePSAction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *SoBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBundle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoMaterialBundle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMaterialBundle *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoMaterialBundle" "', argument " "1"" of type '" "SoAction *""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  result = (SoMaterialBundle *)new SoMaterialBundle(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMaterialBundle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMaterialBundle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMaterialBundle" "', argument " "1"" of type '" "SoMaterialBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBundle_setUpMultiple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBundle_setUpMultiple" "', argument " "1"" of type '" "SoMaterialBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  (arg1)->setUpMultiple();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBundle_sendFirst(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBundle_sendFirst" "', argument " "1"" of type '" "SoMaterialBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  (arg1)->sendFirst();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBundle_forceSend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBundle_forceSend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBundle_forceSend" "', argument " "1"" of type '" "SoMaterialBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMaterialBundle_forceSend" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->forceSend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBundle_isColorOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBundle_isColorOnly" "', argument " "1"" of type '" "SoMaterialBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  result = (SbBool)((SoMaterialBundle const *)arg1)->isColorOnly();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterialBundle_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterialBundle *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterialBundle_send", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterialBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterialBundle_send" "', argument " "1"" of type '" "SoMaterialBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterialBundle * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMaterialBundle_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMaterialBundle_send" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->send(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMaterialBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMaterialBundle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMaterialBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBSPTree__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBSPTree *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBSPTree" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBSPTree" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBSPTree *)new SbBSPTree(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBSPTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBSPTree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbBSPTree *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBSPTree" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbBSPTree *)new SbBSPTree(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBSPTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBSPTree__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBSPTree *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBSPTree *)new SbBSPTree();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBSPTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBSPTree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBSPTree", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBSPTree__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbBSPTree__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbBSPTree__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBSPTree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::SbBSPTree(int const,int const)\n"
    "    SbBSPTree::SbBSPTree(int const)\n"
    "    SbBSPTree::SbBSPTree()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbBSPTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBSPTree" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_numPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_numPoints" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  result = (int)((SbBSPTree const *)arg1)->numPoints();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_getPoint" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_getPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SbBSPTree const *)arg1)->getPoint(arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_getPoint" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_getPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_getPoint" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_getPoint" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ((SbBSPTree const *)arg1)->getPoint(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_getPoint", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbBSPTree_getPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_getPoint__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_getPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::getPoint(int const) const\n"
    "    SbBSPTree::getPoint(int const,SbVec3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBSPTree_getUserData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_getUserData" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_getUserData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void *)((SbBSPTree const *)arg1)->getUserData(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_setUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBSPTree_setUserData", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_setUserData" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_setUserData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_setUserData" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setUserData(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_addPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_addPoint" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_addPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_addPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_addPoint" "', argument " "3"" of type '" "void *const""'"); 
  }
  result = (int)(arg1)->addPoint((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_addPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_addPoint" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_addPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_addPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)(arg1)->addPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_addPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_addPoint", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBSPTree_addPoint__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_addPoint__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_addPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::addPoint(SbVec3f const &,void *const)\n"
    "    SbBSPTree::addPoint(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_removePoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_removePoint" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_removePoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_removePoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)(arg1)->removePoint((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_removePoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_removePoint" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_removePoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removePoint(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_removePoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_removePoint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBSPTree_removePoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbBSPTree_removePoint__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_removePoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::removePoint(SbVec3f const &)\n"
    "    SbBSPTree::removePoint(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBSPTree_findPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findPoint" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)((SbBSPTree const *)arg1)->findPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findClosest__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findClosest" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)((SbBSPTree const *)arg1)->findClosest((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_clear__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_clear" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBSPTree_clear" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->clear(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_clear__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_clear" "', argument " "1"" of type '" "SbBSPTree *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_clear(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_clear", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBSPTree_clear__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbBSPTree_clear__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_clear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::clear(int const)\n"
    "    SbBSPTree::clear()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findPoints__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbIntList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findPoints" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findPoints" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findPoints" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbIntList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_findPoints" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findPoints" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  arg3 = reinterpret_cast< SbIntList * >(argp3);
  ((SbBSPTree const *)arg1)->findPoints((SbSphere const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findClosest__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbIntList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findClosest" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbIntList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_findClosest" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findClosest" "', argument " "3"" of type '" "SbIntList &""'"); 
  }
  arg3 = reinterpret_cast< SbIntList * >(argp3);
  result = (int)((SbBSPTree const *)arg1)->findClosest((SbSphere const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getBBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_getBBox" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  result = (SbBox3f *) &((SbBSPTree const *)arg1)->getBBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_getPointsArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_getPointsArrayPtr" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  result = (SbVec3f *)((SbBSPTree const *)arg1)->getPointsArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findPoints__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbList< int > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findPoints" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findPoints" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findPoints" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_int_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_findPoints" "', argument " "3"" of type '" "SbList< int > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findPoints" "', argument " "3"" of type '" "SbList< int > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< int > * >(argp3);
  ((SbBSPTree const *)arg1)->findPoints((SbSphere const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findPoints(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_findPoints", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbIntList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_findPoints__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_int_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_findPoints__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_findPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::findPoints(SbSphere const &,SbIntList &) const\n"
    "    SbBSPTree::findPoints(SbSphere const &,SbList< int > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findClosest__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBSPTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbList< int > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBSPTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBSPTree_findClosest" "', argument " "1"" of type '" "SbBSPTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbBSPTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findClosest" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_int_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBSPTree_findClosest" "', argument " "3"" of type '" "SbList< int > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBSPTree_findClosest" "', argument " "3"" of type '" "SbList< int > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< int > * >(argp3);
  result = (int)((SbBSPTree const *)arg1)->findClosest((SbSphere const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBSPTree_findClosest(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBSPTree_findClosest", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBSPTree_findClosest__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbIntList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_findClosest__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBSPTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_int_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBSPTree_findClosest__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBSPTree_findClosest'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBSPTree::findClosest(SbVec3f const &) const\n"
    "    SbBSPTree::findClosest(SbSphere const &,SbIntList &) const\n"
    "    SbBSPTree::findClosest(SbSphere const &,SbList< int > &) const\n");
  return 0;
}


SWIGINTERN PyObject *SbBSPTree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBSPTree, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBSPTree_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoNormalGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoNormalGenerator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoNormalGenerator" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoNormalGenerator" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNormalGenerator *)new SoNormalGenerator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNormalGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoNormalGenerator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoNormalGenerator" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SoNormalGenerator *)new SoNormalGenerator(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNormalGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoNormalGenerator", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoNormalGenerator__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SoNormalGenerator__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoNormalGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalGenerator::SoNormalGenerator(SbBool const,int const)\n"
    "    SoNormalGenerator::SoNormalGenerator(SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoNormalGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNormalGenerator" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_reset" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_reset" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->reset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_beginPolygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_beginPolygon" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  (arg1)->beginPolygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_polygonVertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_polygonVertex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_polygonVertex" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalGenerator_polygonVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_polygonVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->polygonVertex((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_endPolygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_endPolygon" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  (arg1)->endPolygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_triangle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_triangle", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_triangle" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalGenerator_triangle" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_triangle" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalGenerator_triangle" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_triangle" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalGenerator_triangle" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_triangle" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  (arg1)->triangle((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_quad(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_quad", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_quad" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalGenerator_quad" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_quad" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalGenerator_quad" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_quad" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalGenerator_quad" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_quad" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoNormalGenerator_quad" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_quad" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  (arg1)->quad((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4,(SbVec3f const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  float arg2 ;
  int32_t *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generate" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_generate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalGenerator_generate" "', argument " "3"" of type '" "int32_t const *""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoNormalGenerator_generate" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->generate(arg2,(int32_t const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  float arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generate" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_generate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalGenerator_generate" "', argument " "3"" of type '" "int32_t const *""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  (arg1)->generate(arg2,(int32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generate" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_generate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->generate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNormalGenerator_generate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNormalGenerator_generate__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNormalGenerator_generate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoNormalGenerator_generate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNormalGenerator_generate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalGenerator::generate(float const,int32_t const *,int const)\n"
    "    SoNormalGenerator::generate(float const,int32_t const *)\n"
    "    SoNormalGenerator::generate(float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generatePerStrip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_generatePerStrip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generatePerStrip" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalGenerator_generatePerStrip" "', argument " "2"" of type '" "int32_t const *""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalGenerator_generatePerStrip" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->generatePerStrip((int32_t const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generatePerFace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generatePerFace" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  (arg1)->generatePerFace();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_generateOverall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_generateOverall" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  (arg1)->generateOverall();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_getNumNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_getNumNormals" "', argument " "1"" of type '" "SoNormalGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  result = (int)((SoNormalGenerator const *)arg1)->getNumNormals();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_setNumNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_setNumNormals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_setNumNormals" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_setNumNormals" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNumNormals(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_getNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_getNormals" "', argument " "1"" of type '" "SoNormalGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  result = (SbVec3f *)((SoNormalGenerator const *)arg1)->getNormals();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_getNormal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_getNormal" "', argument " "1"" of type '" "SoNormalGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_getNormal" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (SbVec3f *) &((SoNormalGenerator const *)arg1)->getNormal(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalGenerator_setNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalGenerator *arg1 = 0 ;
  int32_t arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalGenerator_setNormal", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalGenerator_setNormal" "', argument " "1"" of type '" "SoNormalGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalGenerator_setNormal" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalGenerator_setNormal" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNormalGenerator_setNormal" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setNormal(arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNormalGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNormalElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNormalElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoNormalElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoNormalElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_initClass", 0, 0, 0)) SWIG_fail;
  SoNormalElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_init" "', argument " "1"" of type '" "SoNormalElement *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec3f *arg4 = (SbVec3f *)0 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalElement_set" "', argument " "4"" of type '" "SbVec3f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalElement_set" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  SoNormalElement::set(arg1,arg2,arg3,(SbVec3f const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec3f *arg4 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalElement_set" "', argument " "4"" of type '" "SbVec3f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  SoNormalElement::set(arg1,arg2,arg3,(SbVec3f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNormalElement_set", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoNormalElement_set__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoNormalElement_set__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNormalElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalElement::set(SoState *const,SoNode *const,int32_t const,SbVec3f const *const,SbBool const)\n"
    "    SoNormalElement::set(SoState *const,SoNode *const,int32_t const,SbVec3f const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNormalElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoNormalElement *)SoNormalElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_getNum" "', argument " "1"" of type '" "SoNormalElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalElement * >(argp1);
  result = (int32_t)((SoNormalElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_get" "', argument " "1"" of type '" "SoNormalElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoNormalElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_getArrayPtr" "', argument " "1"" of type '" "SoNormalElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalElement * >(argp1);
  result = (SbVec3f *)((SoNormalElement const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalElement_areNormalsUnitLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalElement_areNormalsUnitLength" "', argument " "1"" of type '" "SoNormalElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalElement * >(argp1);
  result = (SbBool)((SoNormalElement const *)arg1)->areNormalsUnitLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLNormalElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLNormalElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLNormalElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLNormalElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLNormalElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLNormalElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLNormalElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLNormalElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLNormalElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLNormalElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLNormalElement_init" "', argument " "1"" of type '" "SoGLNormalElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLNormalElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLNormalElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLNormalElement_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLNormalElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLNormalElement_send", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLNormalElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLNormalElement_send" "', argument " "1"" of type '" "SoGLNormalElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLNormalElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLNormalElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoGLNormalElement const *)arg1)->send(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLNormalElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLNormalElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoNormalBundle_generator_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBundle *arg1 = 0 ;
  SoNormalGenerator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalBundle_generator_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBundle_generator_set" "', argument " "1"" of type '" "SoNormalBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBundle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNormalGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalBundle_generator_set" "', argument " "2"" of type '" "SoNormalGenerator *""'"); 
  }
  arg2 = reinterpret_cast< SoNormalGenerator * >(argp2);
  if (arg1) (arg1)->generator = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalBundle_generator_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNormalGenerator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalBundle_generator_get" "', argument " "1"" of type '" "SoNormalBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalBundle * >(argp1);
  result = (SoNormalGenerator *) ((arg1)->generator);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalBundle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLMultiTextureCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLMultiTextureCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLMultiTextureCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLMultiTextureCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_init" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureCoordinateElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_push" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureCoordinateElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_pop" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureCoordinateElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureCoordinateElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureCoordinateElement_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureCoordinateElement::CoordType)((SoGLMultiTextureCoordinateElement const *)arg1)->getType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureCoordinateElement::CoordType result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_getType" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  result = (SoMultiTextureCoordinateElement::CoordType)((SoGLMultiTextureCoordinateElement const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_getType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLMultiTextureCoordinateElement_getType__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGLMultiTextureCoordinateElement_getType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLMultiTextureCoordinateElement_getType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLMultiTextureCoordinateElement::getType(int const) const\n"
    "    SoGLMultiTextureCoordinateElement::getType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLMultiTextureCoordinateElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLMultiTextureCoordinateElement *)SoGLMultiTextureCoordinateElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_send__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->send(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_send__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3f *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->send(arg2,arg3,(SbVec3f const &)*arg4,(SbVec3f const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_initRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_initRender", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_initRender" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureCoordinateElement_initRender" "', argument " "2"" of type '" "SbBool const *""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLMultiTextureCoordinateElement_initRender" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->initRender((SbBool const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_send__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->send(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_send__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureCoordinateElement_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->send(arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_send(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_send", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGLMultiTextureCoordinateElement_send__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLMultiTextureCoordinateElement_send__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoGLMultiTextureCoordinateElement_send__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoGLMultiTextureCoordinateElement_send__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLMultiTextureCoordinateElement_send'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLMultiTextureCoordinateElement::send(int const,int const) const\n"
    "    SoGLMultiTextureCoordinateElement::send(int const,int const,SbVec3f const &,SbVec3f const &) const\n"
    "    SoGLMultiTextureCoordinateElement::send(int const) const\n"
    "    SoGLMultiTextureCoordinateElement::send(int const,SbVec3f const &,SbVec3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureCoordinateElement_initMulti(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureCoordinateElement_initMulti", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureCoordinateElement_initMulti" "', argument " "1"" of type '" "SoGLMultiTextureCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureCoordinateElement_initMulti" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ((SoGLMultiTextureCoordinateElement const *)arg1)->initMulti(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLMultiTextureCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLMultiTextureCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateBundle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = (SoAction *)0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoTextureCoordinateBundle *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTextureCoordinateBundle" "', argument " "1"" of type '" "SoAction *const""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoTextureCoordinateBundle" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SoTextureCoordinateBundle" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoTextureCoordinateBundle *)new SoTextureCoordinateBundle(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateBundle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateBundle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAction *arg1 = (SoAction *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoTextureCoordinateBundle *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTextureCoordinateBundle" "', argument " "1"" of type '" "SoAction *const""'"); 
  }
  arg1 = reinterpret_cast< SoAction * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoTextureCoordinateBundle" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SoTextureCoordinateBundle *)new SoTextureCoordinateBundle(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateBundle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateBundle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateBundle", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SoTextureCoordinateBundle__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SoTextureCoordinateBundle__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoTextureCoordinateBundle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextureCoordinateBundle::SoTextureCoordinateBundle(SoAction *const,SbBool const,SbBool const)\n"
    "    SoTextureCoordinateBundle::SoTextureCoordinateBundle(SoAction *const,SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoTextureCoordinateBundle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTextureCoordinateBundle" "', argument " "1"" of type '" "SoTextureCoordinateBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_needCoordinates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_needCoordinates" "', argument " "1"" of type '" "SoTextureCoordinateBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  result = (SbBool)((SoTextureCoordinateBundle const *)arg1)->needCoordinates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_isFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_isFunction" "', argument " "1"" of type '" "SoTextureCoordinateBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  result = (SbBool)((SoTextureCoordinateBundle const *)arg1)->isFunction();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_get" "', argument " "1"" of type '" "SoTextureCoordinateBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCoordinateBundle_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_get" "', argument " "1"" of type '" "SoTextureCoordinateBundle *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateBundle_get" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCoordinateBundle_get" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextureCoordinateBundle_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCoordinateBundle_get" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbVec4f *) &(arg1)->get((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBundle_get", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTextureCoordinateBundle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoTextureCoordinateBundle_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTextureCoordinateBundle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoTextureCoordinateBundle_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTextureCoordinateBundle_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextureCoordinateBundle::get(int const)\n"
    "    SoTextureCoordinateBundle::get(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_send__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_send" "', argument " "1"" of type '" "SoTextureCoordinateBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCoordinateBundle_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoTextureCoordinateBundle const *)arg1)->send(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_send__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_send" "', argument " "1"" of type '" "SoTextureCoordinateBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCoordinateBundle_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextureCoordinateBundle_send" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCoordinateBundle_send" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTextureCoordinateBundle_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCoordinateBundle_send" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  ((SoTextureCoordinateBundle const *)arg1)->send(arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_send(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTextureCoordinateBundle_send", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTextureCoordinateBundle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoTextureCoordinateBundle_send__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTextureCoordinateBundle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoTextureCoordinateBundle_send__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTextureCoordinateBundle_send'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextureCoordinateBundle::send(int const) const\n"
    "    SoTextureCoordinateBundle::send(int const,SbVec3f const &,SbVec3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateBundle_needIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateBundle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateBundle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateBundle_needIndices" "', argument " "1"" of type '" "SoTextureCoordinateBundle const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateBundle * >(argp1);
  result = (SbBool)((SoTextureCoordinateBundle const *)arg1)->needIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateBundle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoCache" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoCache *)new SoCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCache, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_ref" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  (arg1)->ref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_unref__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_unref" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCache_unref" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->unref(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_unref__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_unref" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  (arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_unref(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCache_unref", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoCache_unref__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCache_unref__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCache_unref'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCache::unref(SoState *)\n"
    "    SoCache::unref()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCache_addElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  SoElement *arg2 = (SoElement *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCache_addElement", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_addElement" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCache_addElement" "', argument " "2"" of type '" "SoElement const *const""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  (arg1)->addElement((SoElement const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_addCacheDependency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoCache *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCache_addCacheDependency", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_addCacheDependency" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCache_addCacheDependency" "', argument " "2"" of type '" "SoState const *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCache_addCacheDependency" "', argument " "3"" of type '" "SoCache *""'"); 
  }
  arg3 = reinterpret_cast< SoCache * >(argp3);
  (arg1)->addCacheDependency((SoState const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCache_isValid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_isValid" "', argument " "1"" of type '" "SoCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCache_isValid" "', argument " "2"" of type '" "SoState const *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (SbBool)((SoCache const *)arg1)->isValid((SoState const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_getInvalidElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  SoState *arg2 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCache_getInvalidElement", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_getInvalidElement" "', argument " "1"" of type '" "SoCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCache_getInvalidElement" "', argument " "2"" of type '" "SoState const *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (SoElement *)((SoCache const *)arg1)->getInvalidElement((SoState const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCache_invalidate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCache_invalidate" "', argument " "1"" of type '" "SoCache *""'"); 
  }
  arg1 = reinterpret_cast< SoCache * >(argp1);
  (arg1)->invalidate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCache_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoBoundingBoxCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBoundingBoxCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoBoundingBoxCache" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoBoundingBoxCache *)new SoBoundingBoxCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBoundingBoxCache, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoBoundingBoxCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoBoundingBoxCache" "', argument " "1"" of type '" "SoBoundingBoxCache *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  SbXfBox3f *arg2 = 0 ;
  SbBool arg3 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoundingBoxCache_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_set" "', argument " "1"" of type '" "SoBoundingBoxCache *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbXfBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoundingBoxCache_set" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoundingBoxCache_set" "', argument " "2"" of type '" "SbXfBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbXfBox3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBoundingBoxCache_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoBoundingBoxCache_set" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBoundingBoxCache_set" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  (arg1)->set((SbXfBox3f const &)*arg2,arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_getBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbXfBox3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_getBox" "', argument " "1"" of type '" "SoBoundingBoxCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  result = (SbXfBox3f *) &((SoBoundingBoxCache const *)arg1)->getBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbXfBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_getProjectedBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_getProjectedBox" "', argument " "1"" of type '" "SoBoundingBoxCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  result = (SbBox3f *) &((SoBoundingBoxCache const *)arg1)->getProjectedBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_isCenterSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_isCenterSet" "', argument " "1"" of type '" "SoBoundingBoxCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  result = (SbBool)((SoBoundingBoxCache const *)arg1)->isCenterSet();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_getCenter" "', argument " "1"" of type '" "SoBoundingBoxCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  result = (SbVec3f *) &((SoBoundingBoxCache const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_setHasLinesOrPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_setHasLinesOrPoints" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoBoundingBoxCache::setHasLinesOrPoints(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoundingBoxCache_hasLinesOrPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoundingBoxCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoundingBoxCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoundingBoxCache_hasLinesOrPoints" "', argument " "1"" of type '" "SoBoundingBoxCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoundingBoxCache * >(argp1);
  result = (SbBool)((SoBoundingBoxCache const *)arg1)->hasLinesOrPoints();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBoundingBoxCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBoundingBoxCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBoundingBoxCache_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoConvexDataCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoConvexDataCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoConvexDataCache" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoConvexDataCache *)new SoConvexDataCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoConvexDataCache, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoConvexDataCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoConvexDataCache" "', argument " "1"" of type '" "SoConvexDataCache *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_generate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  SoCoordinateElement *arg2 = (SoCoordinateElement *)0 ;
  SbMatrix *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  int32_t *arg6 = 0 ;
  int32_t *arg7 = 0 ;
  int32_t *arg8 = 0 ;
  SoConvexDataCache::Binding arg9 ;
  SoConvexDataCache::Binding arg10 ;
  SoConvexDataCache::Binding arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[10] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConvexDataCache_generate", 10, 10, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_generate" "', argument " "1"" of type '" "SoConvexDataCache *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoConvexDataCache_generate" "', argument " "2"" of type '" "SoCoordinateElement const *const""'"); 
  }
  arg2 = reinterpret_cast< SoCoordinateElement * >(argp2);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoConvexDataCache_generate" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoConvexDataCache_generate" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoConvexDataCache_generate" "', argument " "6"" of type '" "int32_t const *""'"); 
  }
  arg6 = reinterpret_cast< int32_t * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[5], &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoConvexDataCache_generate" "', argument " "7"" of type '" "int32_t const *""'"); 
  }
  arg7 = reinterpret_cast< int32_t * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[6], &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoConvexDataCache_generate" "', argument " "8"" of type '" "int32_t const *""'"); 
  }
  arg8 = reinterpret_cast< int32_t * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoConvexDataCache_generate" "', argument " "9"" of type '" "SoConvexDataCache::Binding""'");
  } 
  arg9 = static_cast< SoConvexDataCache::Binding >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoConvexDataCache_generate" "', argument " "10"" of type '" "SoConvexDataCache::Binding""'");
  } 
  arg10 = static_cast< SoConvexDataCache::Binding >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoConvexDataCache_generate" "', argument " "11"" of type '" "SoConvexDataCache::Binding""'");
  } 
  arg11 = static_cast< SoConvexDataCache::Binding >(val11);
  (arg1)->generate((SoCoordinateElement const *)arg2,(SbMatrix const &)*arg3,(int32_t const *)arg4,arg5,(int32_t const *)arg6,(int32_t const *)arg7,(int32_t const *)arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getCoordIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getCoordIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int32_t *)((SoConvexDataCache const *)arg1)->getCoordIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getNumCoordIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getNumCoordIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int)((SoConvexDataCache const *)arg1)->getNumCoordIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getMaterialIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getMaterialIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int32_t *)((SoConvexDataCache const *)arg1)->getMaterialIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getNumMaterialIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getNumMaterialIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int)((SoConvexDataCache const *)arg1)->getNumMaterialIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getNormalIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getNormalIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int32_t *)((SoConvexDataCache const *)arg1)->getNormalIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getNumNormalIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getNumNormalIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int)((SoConvexDataCache const *)arg1)->getNumNormalIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getTexIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getTexIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int32_t *)((SoConvexDataCache const *)arg1)->getTexIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConvexDataCache_getNumTexIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConvexDataCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConvexDataCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConvexDataCache_getNumTexIndices" "', argument " "1"" of type '" "SoConvexDataCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoConvexDataCache * >(argp1);
  result = (int)((SoConvexDataCache const *)arg1)->getNumTexIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoConvexDataCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoConvexDataCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoConvexDataCache_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *SoGLCacheList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLCacheList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLLazyElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLLazyElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLLazyElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLLazyElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLLazyElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_init" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_push" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_pop" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLazyElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendAllMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendAllMaterial" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLLazyElement::sendAllMaterial(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendNoMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendNoMaterial" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLLazyElement::sendNoMaterial(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendOnlyDiffuseColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendOnlyDiffuseColor" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLLazyElement::sendOnlyDiffuseColor(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendLightModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendLightModel" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendLightModel" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoGLLazyElement::sendLightModel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendPackedDiffuse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendPackedDiffuse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendPackedDiffuse" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendPackedDiffuse" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  SoGLLazyElement::sendPackedDiffuse(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendFlatshading(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendFlatshading", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendFlatshading" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendFlatshading" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoGLLazyElement::sendFlatshading(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendVertexOrdering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoLazyElement::VertexOrdering arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendVertexOrdering", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendVertexOrdering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendVertexOrdering" "', argument " "2"" of type '" "SoLazyElement::VertexOrdering""'");
  } 
  arg2 = static_cast< SoLazyElement::VertexOrdering >(val2);
  SoGLLazyElement::sendVertexOrdering(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendTwosideLighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendTwosideLighting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendTwosideLighting" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendTwosideLighting" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoGLLazyElement::sendTwosideLighting(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendBackfaceCulling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendBackfaceCulling", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendBackfaceCulling" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendBackfaceCulling" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoGLLazyElement::sendBackfaceCulling(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendDiffuseByIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendDiffuseByIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendDiffuseByIndex" "', argument " "1"" of type '" "SoGLLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_sendDiffuseByIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoGLLazyElement const *)arg1)->sendDiffuseByIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_isColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_isColorIndex" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoGLLazyElement::isColorIndex(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLLazyElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_getInstance" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLLazyElement *)SoGLLazyElement::getInstance((SoState const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_send", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_send" "', argument " "1"" of type '" "SoGLLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_send" "', argument " "2"" of type '" "SoState const *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_send" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ((SoGLLazyElement const *)arg1)->send((SoState const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_sendVPPacked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  unsigned char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_sendVPPacked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_sendVPPacked" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_sendVPPacked" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLazyElement_sendVPPacked" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);
  (arg1)->sendVPPacked(arg2,(unsigned char const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_reset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_reset" "', argument " "1"" of type '" "SoGLLazyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_reset" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_reset" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ((SoGLLazyElement const *)arg1)->reset(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setDiffuseElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  SbColor *arg4 = 0 ;
  SoColorPacker *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setDiffuseElt", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setDiffuseElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setDiffuseElt" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setDiffuseElt" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLLazyElement_setDiffuseElt" "', argument " "4"" of type '" "SbColor const *""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLLazyElement_setDiffuseElt" "', argument " "5"" of type '" "SoColorPacker *""'"); 
  }
  arg5 = reinterpret_cast< SoColorPacker * >(argp5);
  (arg1)->setDiffuseElt(arg2,arg3,(SbColor const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setPackedElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  uint32_t *arg4 = 0 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setPackedElt", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setPackedElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setPackedElt" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setPackedElt" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLLazyElement_setPackedElt" "', argument " "4"" of type '" "uint32_t const *""'"); 
  }
  arg4 = reinterpret_cast< uint32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLLazyElement_setPackedElt" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  (arg1)->setPackedElt(arg2,arg3,(uint32_t const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setColorIndexElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setColorIndexElt", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setColorIndexElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setColorIndexElt" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setColorIndexElt" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLLazyElement_setColorIndexElt" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  (arg1)->setColorIndexElt(arg2,arg3,(int32_t const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setTranspElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  float *arg4 = 0 ;
  SoColorPacker *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setTranspElt", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setTranspElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setTranspElt" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setTranspElt" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLLazyElement_setTranspElt" "', argument " "4"" of type '" "float const *""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLLazyElement_setTranspElt" "', argument " "5"" of type '" "SoColorPacker *""'"); 
  }
  arg5 = reinterpret_cast< SoColorPacker * >(argp5);
  (arg1)->setTranspElt(arg2,arg3,(float const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setTranspTypeElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setTranspTypeElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setTranspTypeElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setTranspTypeElt" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  (arg1)->setTranspTypeElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setAmbientElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setAmbientElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setAmbientElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setAmbientElt" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setAmbientElt((SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setEmissiveElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setEmissiveElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setEmissiveElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setEmissiveElt" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setEmissiveElt((SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setSpecularElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setSpecularElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setSpecularElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setSpecularElt" "', argument " "2"" of type '" "SbColor const *""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setSpecularElt((SbColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setShininessElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setShininessElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setShininessElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setShininessElt" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setShininessElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setColorMaterialElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setColorMaterialElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setColorMaterialElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setColorMaterialElt" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setColorMaterialElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_enableBlendingElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_enableBlendingElt", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_enableBlendingElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_enableBlendingElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_enableBlendingElt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLLazyElement_enableBlendingElt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLLazyElement_enableBlendingElt" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->enableBlendingElt(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_disableBlendingElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_disableBlendingElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  (arg1)->disableBlendingElt();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setLightModelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setLightModelElt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setLightModelElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setLightModelElt" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setLightModelElt" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  (arg1)->setLightModelElt(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setMaterialElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  uint32_t arg3 ;
  SoColorPacker *arg4 = 0 ;
  SbColor *arg5 = 0 ;
  int arg6 ;
  float *arg7 = 0 ;
  int arg8 ;
  SbColor *arg9 = 0 ;
  SbColor *arg10 = 0 ;
  SbColor *arg11 = 0 ;
  float arg12 ;
  SbBool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject *swig_obj[13] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setMaterialElt", 13, 13, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoColorPacker, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "4"" of type '" "SoColorPacker *""'"); 
  }
  arg4 = reinterpret_cast< SoColorPacker * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "5"" of type '" "SbColor const *""'"); 
  }
  arg5 = reinterpret_cast< SbColor * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "7"" of type '" "float const *""'"); 
  }
  arg7 = reinterpret_cast< float * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "9"" of type '" "SbColor const &""'"); 
  }
  arg9 = reinterpret_cast< SbColor * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "10"" of type '" "SbColor const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "11"" of type '" "SbColor const &""'"); 
  }
  arg11 = reinterpret_cast< SbColor * >(argp11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SoGLLazyElement_setMaterialElt" "', argument " "13"" of type '" "SbBool""'");
  } 
  arg13 = static_cast< SbBool >(val13);
  (arg1)->setMaterialElt(arg2,arg3,arg4,(SbColor const *)arg5,arg6,(float const *)arg7,arg8,(SbColor const &)*arg9,(SbColor const &)*arg10,(SbColor const &)*arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setVertexOrderingElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoLazyElement::VertexOrdering arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setVertexOrderingElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setVertexOrderingElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setVertexOrderingElt" "', argument " "2"" of type '" "SoLazyElement::VertexOrdering""'");
  } 
  arg2 = static_cast< SoLazyElement::VertexOrdering >(val2);
  (arg1)->setVertexOrderingElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setBackfaceCullingElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setBackfaceCullingElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setBackfaceCullingElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setBackfaceCullingElt" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setBackfaceCullingElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setTwosideLightingElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setTwosideLightingElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setTwosideLightingElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setTwosideLightingElt" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setTwosideLightingElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setShadeModelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setShadeModelElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setShadeModelElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setShadeModelElt" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setShadeModelElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_setAlphaTestElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_setAlphaTestElt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_setAlphaTestElt" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLLazyElement_setAlphaTestElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLLazyElement_setAlphaTestElt" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setAlphaTestElt(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_beginCaching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLLazyElement::GLState *arg2 = 0 ;
  SoGLLazyElement::GLState *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_beginCaching", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_beginCaching" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_beginCaching" "', argument " "2"" of type '" "SoGLLazyElement::GLState *""'"); 
  }
  arg2 = reinterpret_cast< SoGLLazyElement::GLState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLazyElement_beginCaching" "', argument " "3"" of type '" "SoGLLazyElement::GLState *""'"); 
  }
  arg3 = reinterpret_cast< SoGLLazyElement::GLState * >(argp3);
  SoGLLazyElement::beginCaching(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_endCaching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_endCaching" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLLazyElement::endCaching(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_preCacheCall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLLazyElement::GLState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_preCacheCall", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_preCacheCall" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_preCacheCall" "', argument " "2"" of type '" "SoGLLazyElement::GLState const *""'"); 
  }
  arg2 = reinterpret_cast< SoGLLazyElement::GLState * >(argp2);
  result = (SbBool)SoGLLazyElement::preCacheCall((SoState const *)arg1,(SoGLLazyElement::GLState const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_postCacheCall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLLazyElement::GLState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_postCacheCall", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_postCacheCall" "', argument " "1"" of type '" "SoState const *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_postCacheCall" "', argument " "2"" of type '" "SoGLLazyElement::GLState const *""'"); 
  }
  arg2 = reinterpret_cast< SoGLLazyElement::GLState * >(argp2);
  SoGLLazyElement::postCacheCall((SoState const *)arg1,(SoGLLazyElement::GLState const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_mergeCacheInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLLazyElement::GLState *arg2 = 0 ;
  SoGLLazyElement::GLState *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_mergeCacheInfo", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_mergeCacheInfo" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_mergeCacheInfo" "', argument " "2"" of type '" "SoGLLazyElement::GLState *""'"); 
  }
  arg2 = reinterpret_cast< SoGLLazyElement::GLState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoGLLazyElement__GLState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLazyElement_mergeCacheInfo" "', argument " "3"" of type '" "SoGLLazyElement::GLState *""'"); 
  }
  arg3 = reinterpret_cast< SoGLLazyElement::GLState * >(argp3);
  SoGLLazyElement::mergeCacheInfo(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLazyElement_updateColorVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLazyElement *arg1 = 0 ;
  SoVBO *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLazyElement_updateColorVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLazyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLazyElement_updateColorVBO" "', argument " "1"" of type '" "SoGLLazyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLazyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLazyElement_updateColorVBO" "', argument " "2"" of type '" "SoVBO *""'"); 
  }
  arg2 = reinterpret_cast< SoVBO * >(argp2);
  (arg1)->updateColorVBO(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLLazyElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLLazyElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SoGLRenderCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderCache, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGLRenderCache" "', argument " "1"" of type '" "SoGLRenderCache *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderCache * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderCache_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderCache *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderCache_isValid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderCache_isValid" "', argument " "1"" of type '" "SoGLRenderCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderCache_isValid" "', argument " "2"" of type '" "SoState const *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (SbBool)((SoGLRenderCache const *)arg1)->isValid((SoState const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderCache_addNestedCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderCache *arg1 = 0 ;
  SoGLDisplayList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderCache_addNestedCache", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderCache_addNestedCache" "', argument " "1"" of type '" "SoGLRenderCache *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderCache_addNestedCache" "', argument " "2"" of type '" "SoGLDisplayList *""'"); 
  }
  arg2 = reinterpret_cast< SoGLDisplayList * >(argp2);
  (arg1)->addNestedCache(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLRenderCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLRenderCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoNormalCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNormalCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoNormalCache" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoNormalCache *)new SoNormalCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormalCache, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNormalCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNormalCache" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_set" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNormalCache_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNormalCache_set" "', argument " "3"" of type '" "SbVec3f const *const""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->set(arg2,(SbVec3f const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SoNormalGenerator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_set" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNormalGenerator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_set" "', argument " "2"" of type '" "SoNormalGenerator *""'"); 
  }
  arg2 = reinterpret_cast< SoNormalGenerator * >(argp2);
  (arg1)->set(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNormalCache_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNormalGenerator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNormalCache_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNormalCache_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNormalCache_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalCache::set(int const,SbVec3f const *const)\n"
    "    SoNormalCache::set(SoNormalGenerator *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_getNum" "', argument " "1"" of type '" "SoNormalCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  result = (int)((SoNormalCache const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_getNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_getNormals" "', argument " "1"" of type '" "SoNormalCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  result = (SbVec3f *)((SoNormalCache const *)arg1)->getNormals();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_getNumIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_getNumIndices" "', argument " "1"" of type '" "SoNormalCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  result = (int)((SoNormalCache const *)arg1)->getNumIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_getIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_getIndices" "', argument " "1"" of type '" "SoNormalCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  result = (int32_t *)((SoNormalCache const *)arg1)->getIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  float arg6 ;
  SbVec3f *arg7 = 0 ;
  int arg8 ;
  SbBool arg9 ;
  SbBool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertex" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertex" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertex" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerVertex" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertex" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoNormalCache_generatePerVertex" "', argument " "7"" of type '" "SbVec3f const *""'"); 
  }
  arg7 = reinterpret_cast< SbVec3f * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoNormalCache_generatePerVertex" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoNormalCache_generatePerVertex" "', argument " "9"" of type '" "SbBool""'");
  } 
  arg9 = static_cast< SbBool >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoNormalCache_generatePerVertex" "', argument " "10"" of type '" "SbBool""'");
  } 
  arg10 = static_cast< SbBool >(val10);
  (arg1)->generatePerVertex((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6,(SbVec3f const *)arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  float arg6 ;
  SbVec3f *arg7 = 0 ;
  int arg8 ;
  SbBool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertex" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertex" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertex" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerVertex" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertex" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoNormalCache_generatePerVertex" "', argument " "7"" of type '" "SbVec3f const *""'"); 
  }
  arg7 = reinterpret_cast< SbVec3f * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoNormalCache_generatePerVertex" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoNormalCache_generatePerVertex" "', argument " "9"" of type '" "SbBool""'");
  } 
  arg9 = static_cast< SbBool >(val9);
  (arg1)->generatePerVertex((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6,(SbVec3f const *)arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  float arg6 ;
  SbVec3f *arg7 = 0 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertex" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertex" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertex" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerVertex" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertex" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoNormalCache_generatePerVertex" "', argument " "7"" of type '" "SbVec3f const *""'"); 
  }
  arg7 = reinterpret_cast< SbVec3f * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoNormalCache_generatePerVertex" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->generatePerVertex((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6,(SbVec3f const *)arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  float arg6 ;
  SbVec3f *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertex" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertex" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertex" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerVertex" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertex" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoNormalCache_generatePerVertex" "', argument " "7"" of type '" "SbVec3f const *""'"); 
  }
  arg7 = reinterpret_cast< SbVec3f * >(argp7);
  (arg1)->generatePerVertex((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6,(SbVec3f const *)arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertex" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertex" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertex" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerVertex" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertex" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->generatePerVertex((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerVertex", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoNormalCache_generatePerVertex__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbVec3f, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoNormalCache_generatePerVertex__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbVec3f, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SoNormalCache_generatePerVertex__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbVec3f, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SoNormalCache_generatePerVertex__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNormalCache, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SbVec3f, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SoNormalCache_generatePerVertex__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNormalCache_generatePerVertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNormalCache::generatePerVertex(SbVec3f const *const,unsigned int const,int32_t const *,int const,float const,SbVec3f const *,int const,SbBool const,SbBool const)\n"
    "    SoNormalCache::generatePerVertex(SbVec3f const *const,unsigned int const,int32_t const *,int const,float const,SbVec3f const *,int const,SbBool const)\n"
    "    SoNormalCache::generatePerVertex(SbVec3f const *const,unsigned int const,int32_t const *,int const,float const,SbVec3f const *,int const)\n"
    "    SoNormalCache::generatePerVertex(SbVec3f const *const,unsigned int const,int32_t const *,int const,float const,SbVec3f const *)\n"
    "    SoNormalCache::generatePerVertex(SbVec3f const *const,unsigned int const,int32_t const *,int const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerFace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerFace", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerFace" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerFace" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerFace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerFace" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerFace" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerFace" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerFace((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerFaceStrip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerFaceStrip", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerFaceStrip" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerFaceStrip((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerStrip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int32_t *arg4 = 0 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerStrip", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerStrip" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerStrip" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerStrip" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNormalCache_generatePerStrip" "', argument " "4"" of type '" "int32_t const *""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerStrip" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerStrip" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerStrip((SbVec3f const *)arg2,arg3,(int32_t const *)arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerVertexQuad(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int arg4 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerVertexQuad", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerVertexQuad" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerVertexQuad((SbVec3f const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerFaceQuad(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int arg4 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerFaceQuad", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerFaceQuad" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerFaceQuad((SbVec3f const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormalCache_generatePerRowQuad(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormalCache *arg1 = 0 ;
  SbVec3f *arg2 = (SbVec3f *)0 ;
  unsigned int arg3 ;
  int arg4 ;
  int arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormalCache_generatePerRowQuad", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "1"" of type '" "SoNormalCache *""'"); 
  }
  arg1 = reinterpret_cast< SoNormalCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "2"" of type '" "SbVec3f const *const""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoNormalCache_generatePerRowQuad" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->generatePerRowQuad((SbVec3f const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormalCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormalCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNormalCache_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTextureCoordinateCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTextureCoordinateCache" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoTextureCoordinateCache *)new SoTextureCoordinateCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateCache, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTextureCoordinateCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCache, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTextureCoordinateCache" "', argument " "1"" of type '" "SoTextureCoordinateCache *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCache * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCache_generate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCache *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCache_generate", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCache_generate" "', argument " "1"" of type '" "SoTextureCoordinateCache *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCache * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCache_generate" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCoordinateCache_generate" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextureCoordinateCache_generate" "', argument " "3"" of type '" "SbVec3f const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoTextureCoordinateCache_generate" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->generate((SbBox3f const &)*arg2,(SbVec3f const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCache_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCache_get" "', argument " "1"" of type '" "SoTextureCoordinateCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCache * >(argp1);
  result = (SbVec2f *)((SoTextureCoordinateCache const *)arg1)->get();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCache_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCache *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCache, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCache_getNum" "', argument " "1"" of type '" "SoTextureCoordinateCache const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCache * >(argp1);
  result = (int)((SoTextureCoordinateCache const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateCache_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateCache, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateCache_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SoDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDetail" "', argument " "1"" of type '" "SoDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetail_initClasses", 0, 0, 0)) SWIG_fail;
  SoDetail::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetail_copy" "', argument " "1"" of type '" "SoDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoDetail * >(argp1);
  result = (SoDetail *)((SoDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetail_getTypeId" "', argument " "1"" of type '" "SoDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoDetail * >(argp1);
  result = ((SoDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDetail *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetail_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDetail_isOfType" "', argument " "1"" of type '" "SoDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoDetail * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDetail_isOfType" "', argument " "2"" of type '" "SoType const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDetail_isOfType" "', argument " "2"" of type '" "SoType const""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoDetail const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoConeDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConeDetail_getTypeId" "', argument " "1"" of type '" "SoConeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoConeDetail * >(argp1);
  result = ((SoConeDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConeDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoConeDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConeDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoConeDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoConeDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoConeDetail", 0, 0, 0)) SWIG_fail;
  result = (SoConeDetail *)new SoConeDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoConeDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoConeDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConeDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoConeDetail" "', argument " "1"" of type '" "SoConeDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoConeDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConeDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoConeDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConeDetail_copy" "', argument " "1"" of type '" "SoConeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoConeDetail * >(argp1);
  result = (SoDetail *)((SoConeDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConeDetail_setPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConeDetail_setPart" "', argument " "1"" of type '" "SoConeDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoConeDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoConeDetail_setPart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConeDetail_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConeDetail_getPart" "', argument " "1"" of type '" "SoConeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoConeDetail * >(argp1);
  result = (int)((SoConeDetail const *)arg1)->getPart();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoConeDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoConeDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoConeDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCubeDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCubeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCubeDetail_getTypeId" "', argument " "1"" of type '" "SoCubeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCubeDetail * >(argp1);
  result = ((SoCubeDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCubeDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCubeDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCubeDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoCubeDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCubeDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCubeDetail", 0, 0, 0)) SWIG_fail;
  result = (SoCubeDetail *)new SoCubeDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCubeDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoCubeDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCubeDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoCubeDetail" "', argument " "1"" of type '" "SoCubeDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoCubeDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCubeDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoCubeDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCubeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCubeDetail_copy" "', argument " "1"" of type '" "SoCubeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCubeDetail * >(argp1);
  result = (SoDetail *)((SoCubeDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCubeDetail_setPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCubeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCubeDetail_setPart" "', argument " "1"" of type '" "SoCubeDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoCubeDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCubeDetail_setPart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCubeDetail_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCubeDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCubeDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCubeDetail_getPart" "', argument " "1"" of type '" "SoCubeDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCubeDetail * >(argp1);
  result = (int)((SoCubeDetail const *)arg1)->getPart();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCubeDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCubeDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCubeDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCylinderDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinderDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinderDetail_getTypeId" "', argument " "1"" of type '" "SoCylinderDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinderDetail * >(argp1);
  result = ((SoCylinderDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinderDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCylinderDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinderDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoCylinderDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCylinderDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCylinderDetail", 0, 0, 0)) SWIG_fail;
  result = (SoCylinderDetail *)new SoCylinderDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCylinderDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoCylinderDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinderDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoCylinderDetail" "', argument " "1"" of type '" "SoCylinderDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinderDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinderDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoCylinderDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinderDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinderDetail_copy" "', argument " "1"" of type '" "SoCylinderDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinderDetail * >(argp1);
  result = (SoDetail *)((SoCylinderDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinderDetail_setPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinderDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinderDetail_setPart" "', argument " "1"" of type '" "SoCylinderDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinderDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCylinderDetail_setPart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinderDetail_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinderDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinderDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinderDetail_getPart" "', argument " "1"" of type '" "SoCylinderDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinderDetail * >(argp1);
  result = (int)((SoCylinderDetail const *)arg1)->getPart();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCylinderDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCylinderDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCylinderDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPointDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_getTypeId" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = ((SoPointDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoPointDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPointDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPointDetail", 0, 0, 0)) SWIG_fail;
  result = (SoPointDetail *)new SoPointDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoPointDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPointDetail" "', argument " "1"" of type '" "SoPointDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoPointDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_copy" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = (SoDetail *)((SoPointDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_getCoordinateIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_getCoordinateIndex" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = (int)((SoPointDetail const *)arg1)->getCoordinateIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_getMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_getMaterialIndex" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = (int)((SoPointDetail const *)arg1)->getMaterialIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_getNormalIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_getNormalIndex" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = (int)((SoPointDetail const *)arg1)->getNormalIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_getTextureCoordIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_getTextureCoordIndex" "', argument " "1"" of type '" "SoPointDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  result = (int)((SoPointDetail const *)arg1)->getTextureCoordIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_setCoordinateIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_setCoordinateIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_setCoordinateIndex" "', argument " "1"" of type '" "SoPointDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPointDetail_setCoordinateIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setCoordinateIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_setMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_setMaterialIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_setMaterialIndex" "', argument " "1"" of type '" "SoPointDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPointDetail_setMaterialIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMaterialIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_setNormalIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_setNormalIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_setNormalIndex" "', argument " "1"" of type '" "SoPointDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPointDetail_setNormalIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNormalIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointDetail_setTextureCoordIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointDetail_setTextureCoordIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointDetail_setTextureCoordIndex" "', argument " "1"" of type '" "SoPointDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoPointDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPointDetail_setTextureCoordIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setTextureCoordIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPointDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFaceDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getTypeId" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = ((SoFaceDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFaceDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoFaceDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFaceDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFaceDetail", 0, 0, 0)) SWIG_fail;
  result = (SoFaceDetail *)new SoFaceDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFaceDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoFaceDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoFaceDetail" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoFaceDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_copy" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = (SoDetail *)((SoFaceDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getNumPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getNumPoints" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = (int)((SoFaceDetail const *)arg1)->getNumPoints();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPointDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_getPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getPoint" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFaceDetail_getPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPointDetail *)((SoFaceDetail const *)arg1)->getPoint(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPointDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getPoints" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = (SoPointDetail *)(arg1)->getPoints();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getFaceIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getFaceIndex" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = (int)((SoFaceDetail const *)arg1)->getFaceIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_getPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_getPartIndex" "', argument " "1"" of type '" "SoFaceDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  result = (int)((SoFaceDetail const *)arg1)->getPartIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_setNumPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_setNumPoints", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_setNumPoints" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFaceDetail_setNumPoints" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNumPoints(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_setPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  int arg2 ;
  SoPointDetail *arg3 = (SoPointDetail *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_setPoint", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_setPoint" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFaceDetail_setPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFaceDetail_setPoint" "', argument " "3"" of type '" "SoPointDetail const *const""'"); 
  }
  arg3 = reinterpret_cast< SoPointDetail * >(argp3);
  (arg1)->setPoint(arg2,(SoPointDetail const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_setFaceIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_setFaceIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_setFaceIndex" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFaceDetail_setFaceIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFaceIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_setPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceDetail_setPartIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_setPartIndex" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFaceDetail_setPartIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPartIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_incFaceIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_incFaceIndex" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  (arg1)->incFaceIndex();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceDetail_incPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceDetail_incPartIndex" "', argument " "1"" of type '" "SoFaceDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceDetail * >(argp1);
  (arg1)->incPartIndex();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFaceDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFaceDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFaceDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLineDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_getTypeId" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = ((SoLineDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLineDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoLineDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLineDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLineDetail", 0, 0, 0)) SWIG_fail;
  result = (SoLineDetail *)new SoLineDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLineDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoLineDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoLineDetail" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoLineDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_copy" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = (SoDetail *)((SoLineDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_getPoint0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPointDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_getPoint0" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = (SoPointDetail *)((SoLineDetail const *)arg1)->getPoint0();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_getPoint1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPointDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_getPoint1" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = (SoPointDetail *)((SoLineDetail const *)arg1)->getPoint1();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_getLineIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_getLineIndex" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = (int)((SoLineDetail const *)arg1)->getLineIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_getPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_getPartIndex" "', argument " "1"" of type '" "SoLineDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  result = (int)((SoLineDetail const *)arg1)->getPartIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_setPoint0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  SoPointDetail *arg2 = (SoPointDetail *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_setPoint0", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_setPoint0" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineDetail_setPoint0" "', argument " "2"" of type '" "SoPointDetail const *const""'"); 
  }
  arg2 = reinterpret_cast< SoPointDetail * >(argp2);
  (arg1)->setPoint0((SoPointDetail const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_setPoint1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  SoPointDetail *arg2 = (SoPointDetail *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_setPoint1", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_setPoint1" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPointDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineDetail_setPoint1" "', argument " "2"" of type '" "SoPointDetail const *const""'"); 
  }
  arg2 = reinterpret_cast< SoPointDetail * >(argp2);
  (arg1)->setPoint1((SoPointDetail const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_setLineIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_setLineIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_setLineIndex" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineDetail_setLineIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setLineIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_setPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineDetail_setPartIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_setPartIndex" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineDetail_setPartIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPartIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_incLineIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_incLineIndex" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  (arg1)->incLineIndex();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineDetail_incPartIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineDetail_incPartIndex" "', argument " "1"" of type '" "SoLineDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLineDetail * >(argp1);
  (arg1)->incPartIndex();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLineDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLineDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLineDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodeKitDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_getTypeId" "', argument " "1"" of type '" "SoNodeKitDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  result = ((SoNodeKitDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNodeKitDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoNodeKitDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeKitDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodeKitDetail", 0, 0, 0)) SWIG_fail;
  result = (SoNodeKitDetail *)new SoNodeKitDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeKitDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNodeKitDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNodeKitDetail" "', argument " "1"" of type '" "SoNodeKitDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoNodeKitDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_copy" "', argument " "1"" of type '" "SoNodeKitDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  result = (SoDetail *)((SoNodeKitDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_setNodeKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  SoBaseKit *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_setNodeKit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_setNodeKit" "', argument " "1"" of type '" "SoNodeKitDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitDetail_setNodeKit" "', argument " "2"" of type '" "SoBaseKit *""'"); 
  }
  arg2 = reinterpret_cast< SoBaseKit * >(argp2);
  (arg1)->setNodeKit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_getNodeKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBaseKit *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_getNodeKit" "', argument " "1"" of type '" "SoNodeKitDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  result = (SoBaseKit *)((SoNodeKitDetail const *)arg1)->getNodeKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseKit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_setPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_setPart" "', argument " "1"" of type '" "SoNodeKitDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitDetail_setPart" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_getPart" "', argument " "1"" of type '" "SoNodeKitDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  result = (SoNode *)((SoNodeKitDetail const *)arg1)->getPart();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_setPartName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitDetail_setPartName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_setPartName" "', argument " "1"" of type '" "SoNodeKitDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setPartName((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitDetail_getPartName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitDetail_getPartName" "', argument " "1"" of type '" "SoNodeKitDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitDetail * >(argp1);
  result = (SbName *) &((SoNodeKitDetail const *)arg1)->getPartName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeKitDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeKitDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodeKitDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_getTypeId" "', argument " "1"" of type '" "SoTextDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  result = ((SoTextDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_cleanupClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_cleanupClass", 0, 0, 0)) SWIG_fail;
  SoTextDetail::cleanupClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextDetail", 0, 0, 0)) SWIG_fail;
  result = (SoTextDetail *)new SoTextDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextDetail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTextDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTextDetail" "', argument " "1"" of type '" "SoTextDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoTextDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_copy" "', argument " "1"" of type '" "SoTextDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  result = (SoDetail *)((SoTextDetail const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_getStringIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_getStringIndex" "', argument " "1"" of type '" "SoTextDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  result = (int)((SoTextDetail const *)arg1)->getStringIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_getCharacterIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_getCharacterIndex" "', argument " "1"" of type '" "SoTextDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  result = (int)((SoTextDetail const *)arg1)->getCharacterIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_getPart" "', argument " "1"" of type '" "SoTextDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  result = (int)((SoTextDetail const *)arg1)->getPart();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_setStringIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_setStringIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_setStringIndex" "', argument " "1"" of type '" "SoTextDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextDetail_setStringIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setStringIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_setCharacterIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_setCharacterIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_setCharacterIndex" "', argument " "1"" of type '" "SoTextDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextDetail_setCharacterIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setCharacterIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextDetail_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextDetail *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextDetail_setPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextDetail_setPart" "', argument " "1"" of type '" "SoTextDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoTextDetail * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextDetail_setPart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFNode", 0, 0, 0)) SWIG_fail;
  result = (SoSFNode *)new SoSFNode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFNode" "', argument " "1"" of type '" "SoSFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFNode::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFNode::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_getTypeId" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  result = ((SoSFNode const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_copyFrom" "', argument " "1"" of type '" "SoSFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFNode_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_isSame" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFNode_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFNode const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_getValue" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  result = (SoNode *)((SoSFNode const *)arg1)->getValue();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_setValue" "', argument " "1"" of type '" "SoSFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode_setValue" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode___eq__" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode___eq__" "', argument " "2"" of type '" "SoSFNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFNode___eq__" "', argument " "2"" of type '" "SoSFNode const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  result = (int)((SoSFNode const *)arg1)->operator ==((SoSFNode const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFNode___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode___ne__" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode___ne__" "', argument " "2"" of type '" "SoSFNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFNode___ne__" "', argument " "2"" of type '" "SoSFNode const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  result = (int)((SoSFNode const *)arg1)->operator !=((SoSFNode const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFNode_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_initClass", 0, 0, 0)) SWIG_fail;
  SoSFNode::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFNode_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_fixCopy" "', argument " "1"" of type '" "SoSFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFNode_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_referencesCopy" "', argument " "1"" of type '" "SoSFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  result = (SbBool)((SoSFNode const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFNode *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFNode_setValue" "', argument " "1"" of type '" "SoSFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoSFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFNode_setValue" "', argument " "2"" of type '" "SoSFNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  SoSFNode_setValue__SWIG_1(arg1,(SoSFNode const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFNode_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFNode_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFNode_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFNode_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFNode_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFNode::setValue(SoNode *)\n"
    "    SoSFNode::setValue(SoSFNode const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodekitCatalog_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_initClass", 0, 0, 0)) SWIG_fail;
  SoNodekitCatalog::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)new SoNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNodekitCatalog" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getNumEntries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getNumEntries" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  result = (int)((SoNodekitCatalog const *)arg1)->getNumEntries();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getPartNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getPartNumber", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getPartNumber" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SoNodekitCatalog const *)arg1)->getPartNumber((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getName" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &((SoNodekitCatalog const *)arg1)->getName(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SoNodekitCatalog const *)arg1)->getType(arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = ((SoNodekitCatalog const *)arg1)->getType((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getType(int) const\n"
    "    SoNodekitCatalog::getType(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getDefaultType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getDefaultType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getDefaultType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SoNodekitCatalog const *)arg1)->getDefaultType(arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getDefaultType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getDefaultType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = ((SoNodekitCatalog const *)arg1)->getDefaultType((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getDefaultType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getDefaultType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getDefaultType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getDefaultType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getDefaultType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getDefaultType(int) const\n"
    "    SoNodekitCatalog::getDefaultType(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isNullByDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isNullByDefault" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_isNullByDefault" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isNullByDefault(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isNullByDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isNullByDefault" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isNullByDefault((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isNullByDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_isNullByDefault", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isNullByDefault__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isNullByDefault__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_isNullByDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::isNullByDefault(int) const\n"
    "    SoNodekitCatalog::isNullByDefault(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isLeaf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isLeaf" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_isLeaf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isLeaf(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isLeaf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isLeaf" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isLeaf((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isLeaf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_isLeaf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isLeaf__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isLeaf__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_isLeaf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::isLeaf(int) const\n"
    "    SoNodekitCatalog::isLeaf(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getParentName" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getParentName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &((SoNodekitCatalog const *)arg1)->getParentName(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getParentName" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbName *) &((SoNodekitCatalog const *)arg1)->getParentName((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getParentName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getParentName__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getParentName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getParentName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getParentName(int) const\n"
    "    SoNodekitCatalog::getParentName(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentPartNumber__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getParentPartNumber" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getParentPartNumber" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoNodekitCatalog const *)arg1)->getParentPartNumber(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentPartNumber__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getParentPartNumber" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SoNodekitCatalog const *)arg1)->getParentPartNumber((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getParentPartNumber(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getParentPartNumber", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getParentPartNumber__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getParentPartNumber__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getParentPartNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getParentPartNumber(int) const\n"
    "    SoNodekitCatalog::getParentPartNumber(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getRightSiblingName" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getRightSiblingName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &((SoNodekitCatalog const *)arg1)->getRightSiblingName(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbName *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getRightSiblingName" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbName *) &((SoNodekitCatalog const *)arg1)->getRightSiblingName((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getRightSiblingName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getRightSiblingName__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getRightSiblingName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getRightSiblingName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getRightSiblingName(int) const\n"
    "    SoNodekitCatalog::getRightSiblingName(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingPartNumber__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getRightSiblingPartNumber" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getRightSiblingPartNumber" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((SoNodekitCatalog const *)arg1)->getRightSiblingPartNumber(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingPartNumber__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getRightSiblingPartNumber" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)((SoNodekitCatalog const *)arg1)->getRightSiblingPartNumber((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getRightSiblingPartNumber(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getRightSiblingPartNumber", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getRightSiblingPartNumber__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getRightSiblingPartNumber__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getRightSiblingPartNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getRightSiblingPartNumber(int) const\n"
    "    SoNodekitCatalog::getRightSiblingPartNumber(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isList" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_isList" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isList(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isList" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isList((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_isList", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isList__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isList__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_isList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::isList(int) const\n"
    "    SoNodekitCatalog::isList(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListContainerType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getListContainerType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getListContainerType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SoNodekitCatalog const *)arg1)->getListContainerType(arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListContainerType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoType result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getListContainerType" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = ((SoNodekitCatalog const *)arg1)->getListContainerType((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListContainerType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getListContainerType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getListContainerType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getListContainerType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getListContainerType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getListContainerType(int) const\n"
    "    SoNodekitCatalog::getListContainerType(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListItemTypes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getListItemTypes" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_getListItemTypes" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoTypeList *) &((SoNodekitCatalog const *)arg1)->getListItemTypes(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListItemTypes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_getListItemTypes" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoTypeList *) &((SoNodekitCatalog const *)arg1)->getListItemTypes((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_getListItemTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_getListItemTypes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getListItemTypes__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_getListItemTypes__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_getListItemTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::getListItemTypes(int) const\n"
    "    SoNodekitCatalog::getListItemTypes(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isPublic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isPublic" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_isPublic" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isPublic(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isPublic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_isPublic" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SoNodekitCatalog const *)arg1)->isPublic((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_isPublic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_isPublic", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isPublic__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoNodekitCatalog_isPublic__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_isPublic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::isPublic(int) const\n"
    "    SoNodekitCatalog::isPublic(SbName const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_clone", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_clone" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodekitCatalog_clone" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_clone" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SoNodekitCatalog *)((SoNodekitCatalog const *)arg1)->clone(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_addEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoType arg3 ;
  SoType arg4 ;
  SbBool arg5 ;
  SbName *arg6 = 0 ;
  SbName *arg7 = 0 ;
  SbBool arg8 ;
  SoType arg9 ;
  SoType arg10 ;
  SbBool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[11] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_addEntry", 11, 11, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_addEntry" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodekitCatalog_addEntry" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addEntry" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNodekitCatalog_addEntry" "', argument " "4"" of type '" "SoType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addEntry" "', argument " "4"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoNodekitCatalog_addEntry" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  {
    if (PyBytes_Check(swig_obj[5]))
    {
      arg6 = new SbName(PyBytes_AsString(swig_obj[5]));
    }
    else if  (PyUnicode_Check(swig_obj[5])){
      arg6 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[5], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg6 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[5], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg6 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[6]))
    {
      arg7 = new SbName(PyBytes_AsString(swig_obj[6]));
    }
    else if  (PyUnicode_Check(swig_obj[6])){
      arg7 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[6], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg7 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[6], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg7 = *tmp;
    }
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoNodekitCatalog_addEntry" "', argument " "8"" of type '" "SbBool""'");
  } 
  arg8 = static_cast< SbBool >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoNodekitCatalog_addEntry" "', argument " "9"" of type '" "SoType""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addEntry" "', argument " "9"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoNodekitCatalog_addEntry" "', argument " "10"" of type '" "SoType""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addEntry" "', argument " "10"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoNodekitCatalog_addEntry" "', argument " "11"" of type '" "SbBool""'");
  } 
  arg11 = static_cast< SbBool >(val11);
  result = (SbBool)(arg1)->addEntry((SbName const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,(SbName const &)*arg6,(SbName const &)*arg7,arg8,SWIG_STD_MOVE(arg9),SWIG_STD_MOVE(arg10),arg11);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg6) {
      delete arg6; 
    }
  }
  {
    if (arg7) {
      delete arg7; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg6) {
      delete arg6; 
    }
  }
  {
    if (arg7) {
      delete arg7; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_addListItemType__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  SoType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_addListItemType" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_addListItemType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodekitCatalog_addListItemType" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addListItemType" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->addListItemType(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_addListItemType__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_addListItemType" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodekitCatalog_addListItemType" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_addListItemType" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->addListItemType((SbName const &)*arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_addListItemType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_addListItemType", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNodekitCatalog_addListItemType__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodekitCatalog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNodekitCatalog_addListItemType__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodekitCatalog_addListItemType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodekitCatalog::addListItemType(int,SoType)\n"
    "    SoNodekitCatalog::addListItemType(SbName const &,SoType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_narrowTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoType arg3 ;
  SoType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_narrowTypes", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_narrowTypes" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodekitCatalog_narrowTypes" "', argument " "3"" of type '" "SoType""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_narrowTypes" "', argument " "3"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNodekitCatalog_narrowTypes" "', argument " "4"" of type '" "SoType""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodekitCatalog_narrowTypes" "', argument " "4"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->narrowTypes((SbName const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_setNullByDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_setNullByDefault", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_setNullByDefault" "', argument " "1"" of type '" "SoNodekitCatalog *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNodekitCatalog_setNullByDefault" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setNullByDefault((SbName const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_recursiveSearch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  int arg2 ;
  SbName *arg3 = 0 ;
  SoTypeList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodekitCatalog_recursiveSearch", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_recursiveSearch" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodekitCatalog_recursiveSearch" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoTypeList, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNodekitCatalog_recursiveSearch" "', argument " "4"" of type '" "SoTypeList *""'"); 
  }
  arg4 = reinterpret_cast< SoTypeList * >(argp4);
  result = (SbBool)((SoNodekitCatalog const *)arg1)->recursiveSearch(arg2,(SbName const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodekitCatalog_printCheck(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodekitCatalog_printCheck" "', argument " "1"" of type '" "SoNodekitCatalog const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodekitCatalog * >(argp1);
  ((SoNodekitCatalog const *)arg1)->printCheck();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodekitCatalog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodekitCatalog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodekitCatalog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFName", 0, 0, 0)) SWIG_fail;
  result = (SoSFName *)new SoSFName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFName" "', argument " "1"" of type '" "SoSFName *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFName::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFName::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_getTypeId" "', argument " "1"" of type '" "SoSFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  result = ((SoSFName const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_copyFrom" "', argument " "1"" of type '" "SoSFName *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFName_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_isSame" "', argument " "1"" of type '" "SoSFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFName_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFName const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_getValue" "', argument " "1"" of type '" "SoSFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  result = (SbName *) &((SoSFName const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_setValue" "', argument " "1"" of type '" "SoSFName *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName___eq__" "', argument " "1"" of type '" "SoSFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName___eq__" "', argument " "2"" of type '" "SoSFName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFName___eq__" "', argument " "2"" of type '" "SoSFName const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  result = (int)((SoSFName const *)arg1)->operator ==((SoSFName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFName___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName___ne__" "', argument " "1"" of type '" "SoSFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName___ne__" "', argument " "2"" of type '" "SoSFName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFName___ne__" "', argument " "2"" of type '" "SoSFName const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  result = (int)((SoSFName const *)arg1)->operator !=((SoSFName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFName_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFName_initClass", 0, 0, 0)) SWIG_fail;
  SoSFName::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_setValue" "', argument " "1"" of type '" "SoSFName *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName_setValue" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setValue((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFName *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFName_setValue" "', argument " "1"" of type '" "SoSFName *""'"); 
  }
  arg1 = reinterpret_cast< SoSFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFName_setValue" "', argument " "2"" of type '" "SoSFName const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  SoSFName_setValue__SWIG_2(arg1,(SoSFName const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFName_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFName_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFName, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFName_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFName_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSFName_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFName_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFName::setValue(SbName const &)\n"
    "    SoSFName::setValue(char const *const)\n"
    "    SoSFName::setValue(SoSFName const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFName", 0, 0, 0)) SWIG_fail;
  result = (SoMFName *)new SoMFName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFName" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFName::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFName::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_getTypeId" "', argument " "1"" of type '" "SoMFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  result = ((SoMFName const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_copyFrom" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFName_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_isSame" "', argument " "1"" of type '" "SoMFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFName_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFName const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_find" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFName_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_find" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)(arg1)->find((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFName_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFName_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFName_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFName_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFName::find(SbName const &,SbBool)\n"
    "    SoMFName::find(SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbName *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_setValues" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFName_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFName_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFName_setValues" "', argument " "4"" of type '" "SbName const *""'"); 
  }
  arg4 = reinterpret_cast< SbName * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbName const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int arg2 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_set1Value" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFName_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  (arg1)->set1Value(arg2,(SbName const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_setValue" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SoMFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName___eq__" "', argument " "1"" of type '" "SoMFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName___eq__" "', argument " "2"" of type '" "SoMFName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFName___eq__" "', argument " "2"" of type '" "SoMFName const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFName * >(argp2);
  result = (SbBool)((SoMFName const *)arg1)->operator ==((SoMFName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFName___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SoMFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName___ne__" "', argument " "1"" of type '" "SoMFName const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFName,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName___ne__" "', argument " "2"" of type '" "SoMFName const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFName___ne__" "', argument " "2"" of type '" "SoMFName const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFName * >(argp2);
  result = (SbBool)((SoMFName const *)arg1)->operator !=((SoMFName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFName_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_startEditing" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  result = (SbName *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_finishEditing" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName_initClass", 0, 0, 0)) SWIG_fail;
  SoMFName::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  char **arg4 = (char **)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_setValues" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFName_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFName_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;  
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = (char **)malloc(len * sizeof(char *));
        for (int i = 0; i < len; i++) {
          PyObject * item = PySequence_GetItem(swig_obj[3],i);
          if (PyBytes_Check(item))
          {
            arg4[i] = PyBytes_AsString(item);
          }
          else if  (PyUnicode_Check(item))
          {
            arg4[i] = PyBytes_AsString(PyUnicode_AsEncodedString(item, "utf-8", "Error ~"));
          }
          else
          {
            arg4[i] = PyBytes_AsString(PyUnicode_AsEncodedString(PyObject_Str(item), "utf-8", "Error ~"));
          }
          
          Py_DECREF(item);
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      return NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(char const *(*))arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFName_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbName, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFName_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = PySequence_Check(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_SoMFName_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFName_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFName::setValues(int const,int const,SbName const *)\n"
    "    SoMFName::setValues(int const,int const,char const *[])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_setValue" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName_setValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setValue((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName___getitem__" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFName___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &SoMFName___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int arg2 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFName___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName___setitem__" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFName___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  SoMFName___setitem__(arg1,arg2,(SbName const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  SoMFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_setValue" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFName_setValue" "', argument " "2"" of type '" "SoMFName const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFName * >(argp2);
  SoMFName_setValue__SWIG_2(arg1,(SoMFName const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFName_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFName, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFName_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFName_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFName_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFName_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFName::setValue(SbName const &)\n"
    "    SoMFName::setValue(char const *)\n"
    "    SoMFName::setValue(SoMFName const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFName_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbName *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_getValues" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFName_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbName *)SoMFName___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyObject * str = 
        
        
        
        PyUnicode_DecodeUTF8(result[i].getString(), strlen(result[i].getString()), "Error ~");
        
        PyList_SetItem(resultobj, i, str);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFName *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbName *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFName_getValues" "', argument " "1"" of type '" "SoMFName *""'"); 
  }
  arg1 = reinterpret_cast< SoMFName * >(argp1);
  result = (SbName *)SoMFName___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyObject * str = 
        
        
        
        PyUnicode_DecodeUTF8(result[i].getString(), strlen(result[i].getString()), "Error ~");
        
        PyList_SetItem(resultobj, i, str);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFName_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFName_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFName_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFName, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFName_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFName_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFName::__getValuesHelper__(int &,int)\n"
    "    SoMFName::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNodeKitListPart::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getTypeId" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = ((SoNodeKitListPart const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_initClass", 0, 0, 0)) SWIG_fail;
  SoNodeKitListPart::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeKitListPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodeKitListPart", 0, 0, 0)) SWIG_fail;
  result = (SoNodeKitListPart *)new SoNodeKitListPart();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeKitListPart, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getContainerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getContainerType" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = ((SoNodeKitListPart const *)arg1)->getContainerType();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_setContainerType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_setContainerType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_setContainerType" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_setContainerType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeKitListPart_setContainerType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setContainerType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getChildTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTypeList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getChildTypes" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = (SoTypeList *) &((SoNodeKitListPart const *)arg1)->getChildTypes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTypeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_addChildType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_addChildType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_addChildType" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_addChildType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeKitListPart_addChildType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->addChildType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_isTypePermitted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_isTypePermitted", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_isTypePermitted" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_isTypePermitted" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeKitListPart_isTypePermitted" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoNodeKitListPart const *)arg1)->isTypePermitted(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_isChildPermitted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_isChildPermitted", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_isChildPermitted" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_isChildPermitted" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbBool)((SoNodeKitListPart const *)arg1)->isChildPermitted((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_containerSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_containerSet", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_containerSet" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_containerSet" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->containerSet((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_lockTypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_lockTypes" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  (arg1)->lockTypes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_isTypeLocked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_isTypeLocked" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = (SbBool)((SoNodeKitListPart const *)arg1)->isTypeLocked();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_addChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_addChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_addChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_insertChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_insertChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_insertChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoNodeKitListPart_insertChild" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getChild" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitListPart_getChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoNodeKitListPart const *)arg1)->getChild(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_findChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_findChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_findChild" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_findChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoNodeKitListPart const *)arg1)->findChild(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getNumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getNumChildren" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = (int)((SoNodeKitListPart const *)arg1)->getNumChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_removeChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_removeChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitListPart_removeChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_removeChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_removeChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_removeChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_removeChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_removeChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitListPart, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNodeKitListPart_removeChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitListPart, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoNodeKitListPart_removeChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodeKitListPart_removeChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodeKitListPart::removeChild(int)\n"
    "    SoNodeKitListPart::removeChild(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_replaceChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_replaceChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNodeKitListPart_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_replaceChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitListPart, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNodeKitListPart_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitListPart, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoNodeKitListPart_replaceChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodeKitListPart_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodeKitListPart::replaceChild(int,SoNode *)\n"
    "    SoNodeKitListPart::replaceChild(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_affectsState" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = (SbBool)((SoNodeKitListPart const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_doAction" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_callback" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_GLRender" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getBoundingBox" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getMatrix" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_handleEvent" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_pick" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_search" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitListPart_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getPrimitiveCount" "', argument " "1"" of type '" "SoNodeKitListPart *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitListPart_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitListPart_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitListPart *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitListPart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitListPart_getChildren" "', argument " "1"" of type '" "SoNodeKitListPart const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitListPart * >(argp1);
  result = (SoChildList *)((SoNodeKitListPart const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeKitListPart_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeKitListPart, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodeKitListPart_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodeKitPath_getLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_getLength" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  result = (int)((SoNodeKitPath const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_getTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_getTail" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  result = (SoNode *)((SoNodeKitPath const *)arg1)->getTail();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_getNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath_getNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_getNode" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitPath_getNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoNodeKitPath const *)arg1)->getNode(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_getNodeFromTail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath_getNodeFromTail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_getNodeFromTail" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitPath_getNodeFromTail" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoNodeKitPath const *)arg1)->getNodeFromTail(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_truncate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath_truncate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_truncate" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoNodeKitPath_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_pop" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  (arg1)->pop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoBaseKit *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_append" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath_append" "', argument " "2"" of type '" "SoBaseKit *""'"); 
  }
  arg2 = reinterpret_cast< SoBaseKit * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoNodeKitPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_append" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath_append" "', argument " "2"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeKitPath * >(argp2);
  (arg1)->append((SoNodeKitPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoNodeKitPath_append", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoBaseKit, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNodeKitPath_append__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNodeKitPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNodeKitPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoNodeKitPath_append__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoNodeKitPath_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoNodeKitPath::append(SoBaseKit *)\n"
    "    SoNodeKitPath::append(SoNodeKitPath const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_containsNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoBaseKit *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath_containsNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_containsNode" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath_containsNode" "', argument " "2"" of type '" "SoBaseKit *""'"); 
  }
  arg2 = reinterpret_cast< SoBaseKit * >(argp2);
  result = (SbBool)((SoNodeKitPath const *)arg1)->containsNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath_findFork(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoNodeKitPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath_findFork", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath_findFork" "', argument " "1"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath_findFork" "', argument " "2"" of type '" "SoNodeKitPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeKitPath * >(argp2);
  result = (int)((SoNodeKitPath const *)arg1)->findFork((SoNodeKitPath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoNodeKitPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath___eq__" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoNodeKitPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath___eq__" "', argument " "2"" of type '" "SoNodeKitPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeKitPath___eq__" "', argument " "2"" of type '" "SoNodeKitPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoNodeKitPath * >(argp2);
  result = (int)SoNodeKitPath___eq__(arg1,(SoNodeKitPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoNodeKitPath___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKitPath *arg1 = 0 ;
  SoNodeKitPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKitPath___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeKitPath___nq__" "', argument " "1"" of type '" "SoNodeKitPath *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKitPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoNodeKitPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeKitPath___nq__" "', argument " "2"" of type '" "SoNodeKitPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeKitPath___nq__" "', argument " "2"" of type '" "SoNodeKitPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoNodeKitPath * >(argp2);
  result = (int)SoNodeKitPath___nq__(arg1,(SoNodeKitPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeKitPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeKitPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoChildList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoChildList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoChildList" "', argument " "1"" of type '" "SoNode *const""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoChildList *)new SoChildList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoChildList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = (SoNode *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoChildList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoChildList" "', argument " "1"" of type '" "SoNode *const""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoChildList" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoChildList *)new SoChildList(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoChildList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = (SoNode *)0 ;
  SoChildList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SoChildList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoChildList" "', argument " "1"" of type '" "SoNode *const""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoChildList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoChildList" "', argument " "2"" of type '" "SoChildList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoChildList" "', argument " "2"" of type '" "SoChildList const &""'"); 
  }
  arg2 = reinterpret_cast< SoChildList * >(argp2);
  result = (SoChildList *)new SoChildList(arg1,(SoChildList const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoChildList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoChildList", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoChildList__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoChildList, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SoChildList__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SoChildList__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoChildList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoChildList::SoChildList(SoNode *const)\n"
    "    SoChildList::SoChildList(SoNode *const,int const)\n"
    "    SoChildList::SoChildList(SoNode *const,SoChildList const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoChildList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoChildList" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_append" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_append" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_insert" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_insert" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoChildList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_remove" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoChildList_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_truncate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_truncate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_truncate" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoChildList_truncate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->truncate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoChildList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_copy" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoChildList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_copy" "', argument " "2"" of type '" "SoChildList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoChildList_copy" "', argument " "2"" of type '" "SoChildList const &""'"); 
  }
  arg2 = reinterpret_cast< SoChildList * >(argp2);
  (arg1)->copy((SoChildList const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_set" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoChildList_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoChildList_set" "', argument " "3"" of type '" "SoNode *const""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverseInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoAction *arg2 = (SoAction *)0 ;
  int arg3 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_traverseInPath", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_traverseInPath" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_traverseInPath" "', argument " "2"" of type '" "SoAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoChildList_traverseInPath" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoChildList_traverseInPath" "', argument " "4"" of type '" "int const *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  (arg1)->traverseInPath(arg2,arg3,(int const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoAction *arg2 = (SoAction *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_traverse" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_traverse" "', argument " "2"" of type '" "SoAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->traverse(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoAction *arg2 = (SoAction *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_traverse" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_traverse" "', argument " "2"" of type '" "SoAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoChildList_traverse" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->traverse(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverse__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoAction *arg2 = (SoAction *)0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_traverse" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_traverse" "', argument " "2"" of type '" "SoAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoChildList_traverse" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->traverse(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverse__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoAction *arg2 = (SoAction *)0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_traverse" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_traverse" "', argument " "2"" of type '" "SoAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoChildList_traverse" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoChildList_traverse" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->traverse(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_traverse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoChildList_traverse", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoChildList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoChildList_traverse__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoChildList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoChildList_traverse__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoChildList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoChildList_traverse__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoChildList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoChildList_traverse__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoChildList_traverse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoChildList::traverse(SoAction *const)\n"
    "    SoChildList::traverse(SoAction *const,int const)\n"
    "    SoChildList::traverse(SoAction *const,SoNode *)\n"
    "    SoChildList::traverse(SoAction *const,int const,int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoChildList_addPathAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_addPathAuditor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_addPathAuditor" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_addPathAuditor" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->addPathAuditor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoChildList_removePathAuditor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoChildList *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoChildList_removePathAuditor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoChildList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoChildList_removePathAuditor" "', argument " "1"" of type '" "SoChildList *""'"); 
  }
  arg1 = reinterpret_cast< SoChildList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoChildList_removePathAuditor" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->removePathAuditor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoChildList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoChildList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoChildList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBaseKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBaseKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getTypeId" "', argument " "1"" of type '" "SoBaseKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  result = ((SoBaseKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_initClass", 0, 0, 0)) SWIG_fail;
  SoBaseKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBaseKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBaseKit", 0, 0, 0)) SWIG_fail;
  result = (SoBaseKit *)new SoBaseKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoBaseKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getNodekitCatalog" "', argument " "1"" of type '" "SoBaseKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  result = (SoNodekitCatalog *)((SoBaseKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getPart", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getPart" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseKit_getPart" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoNode *)(arg1)->getPart((SbName const &)*arg2,arg3);
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getPartString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getPartString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getPartString" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_getPartString" "', argument " "2"" of type '" "SoBase const *""'"); 
  }
  arg2 = reinterpret_cast< SoBase * >(argp2);
  result = (arg1)->getPartString((SoBase const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_createPathToPart__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  SoPath *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SoNodeKitPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_createPathToPart" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseKit_createPathToPart" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoBaseKit_createPathToPart" "', argument " "4"" of type '" "SoPath const *""'"); 
  }
  arg4 = reinterpret_cast< SoPath * >(argp4);
  result = (SoNodeKitPath *)(arg1)->createPathToPart((SbName const &)*arg2,arg3,(SoPath const *)arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_createPathToPart__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoNodeKitPath *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_createPathToPart" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseKit_createPathToPart" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoNodeKitPath *)(arg1)->createPathToPart((SbName const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeKitPath, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_createPathToPart(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoBaseKit_createPathToPart", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoBaseKit_createPathToPart__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoPath, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoBaseKit_createPathToPart__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoBaseKit_createPathToPart'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBaseKit::createPathToPart(SbName const &,SbBool,SoPath const *)\n"
    "    SoBaseKit::createPathToPart(SbName const &,SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_setPart", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_setPart" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBaseKit_setPart" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  result = (SbBool)(arg1)->setPart((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_set" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)(arg1)->set((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_set" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBaseKit_set" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (SbBool)(arg1)->set((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoBaseKit_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBaseKit_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoBaseKit_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoBaseKit_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBaseKit::set(char const *)\n"
    "    SoBaseKit::set(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_doAction" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_callback" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_GLRender" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getBoundingBox" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getMatrix" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_handleEvent" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_rayPick" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_search" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_write" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getPrimitiveCount" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_getChildren" "', argument " "1"" of type '" "SoBaseKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  result = (SoChildList *)((SoBaseKit const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_printDiagram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_printDiagram" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  (arg1)->printDiagram();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_printSubDiagram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_printSubDiagram", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_printSubDiagram" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseKit_printSubDiagram" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->printSubDiagram((SbName const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_printTable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_printTable" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  (arg1)->printTable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_addWriteReference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_addWriteReference" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBaseKit_addWriteReference" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->addWriteReference(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_addWriteReference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_addWriteReference" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->addWriteReference(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_addWriteReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoBaseKit_addWriteReference", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoBaseKit_addWriteReference__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoBaseKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoBaseKit_addWriteReference__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoBaseKit_addWriteReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoBaseKit::addWriteReference(SoOutput *,SbBool)\n"
    "    SoBaseKit::addWriteReference(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_forceChildDrivenWriteRefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseKit *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_forceChildDrivenWriteRefs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseKit_forceChildDrivenWriteRefs" "', argument " "1"" of type '" "SoBaseKit *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseKit_forceChildDrivenWriteRefs" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  result = (SbBool)(arg1)->forceChildDrivenWriteRefs(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_isSearchingChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseKit_isSearchingChildren", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoBaseKit::isSearchingChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseKit_setSearchingChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoBaseKit_setSearchingChildren" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoBaseKit::setSearchingChildren(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBaseKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBaseKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBaseKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SoSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSensor" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_setFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  SoSensorCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensor_setFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_setFunction" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSensor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSensor_setFunction" "', argument " "2"" of type '" "SoSensorCB *""'"); 
    }
  }
  (arg1)->setFunction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_getFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSensorCBPtr result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_getFunction" "', argument " "1"" of type '" "SoSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  result = (SoSensorCBPtr)((SoSensor const *)arg1)->getFunction();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_SoSensor__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_setData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensor_setData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_setData" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensor_setData" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->setData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_getData" "', argument " "1"" of type '" "SoSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  result = (void *)((SoSensor const *)arg1)->getData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_schedule" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  (arg1)->schedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_unschedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_unschedule" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  (arg1)->unschedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_isScheduled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_isScheduled" "', argument " "1"" of type '" "SoSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  result = (SbBool)((SoSensor const *)arg1)->isScheduled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_trigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_trigger" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  (arg1)->trigger();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_isBefore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  SoSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensor_isBefore", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_isBefore" "', argument " "1"" of type '" "SoSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensor_isBefore" "', argument " "2"" of type '" "SoSensor const *""'"); 
  }
  arg2 = reinterpret_cast< SoSensor * >(argp2);
  result = (SbBool)((SoSensor const *)arg1)->isBefore((SoSensor const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_setNextInQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  SoSensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensor_setNextInQueue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_setNextInQueue" "', argument " "1"" of type '" "SoSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSensor_setNextInQueue" "', argument " "2"" of type '" "SoSensor *""'"); 
  }
  arg2 = reinterpret_cast< SoSensor * >(argp2);
  (arg1)->setNextInQueue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_getNextInQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSensor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSensor_getNextInQueue" "', argument " "1"" of type '" "SoSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoSensor * >(argp1);
  result = (SoSensor *)((SoSensor const *)arg1)->getNextInQueue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSensor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoDelayQueueSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDelayQueueSensor", 0, 0, 0)) SWIG_fail;
  result = (SoDelayQueueSensor *)new SoDelayQueueSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDelayQueueSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDelayQueueSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoDelayQueueSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDelayQueueSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoDelayQueueSensor *)new SoDelayQueueSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDelayQueueSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoDelayQueueSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDelayQueueSensor" "', argument " "1"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_setPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDelayQueueSensor_setPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_setPriority" "', argument " "1"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDelayQueueSensor_setPriority" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setPriority(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_getPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_getPriority" "', argument " "1"" of type '" "SoDelayQueueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  result = (uint32_t)((SoDelayQueueSensor const *)arg1)->getPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_getDefaultPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDelayQueueSensor_getDefaultPriority", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoDelayQueueSensor::getDefaultPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_schedule" "', argument " "1"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  (arg1)->schedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_unschedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_unschedule" "', argument " "1"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  (arg1)->unschedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_isScheduled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_isScheduled" "', argument " "1"" of type '" "SoDelayQueueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  result = (SbBool)((SoDelayQueueSensor const *)arg1)->isScheduled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_isIdleOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_isIdleOnly" "', argument " "1"" of type '" "SoDelayQueueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  result = (SbBool)((SoDelayQueueSensor const *)arg1)->isIdleOnly();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDelayQueueSensor_trigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDelayQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDelayQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDelayQueueSensor_trigger" "', argument " "1"" of type '" "SoDelayQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDelayQueueSensor * >(argp1);
  (arg1)->trigger();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDelayQueueSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDelayQueueSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDelayQueueSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SoDataSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoDataSensor" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_setDeleteCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  SoSensorCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_setDeleteCallback" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSensor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDataSensor_setDeleteCallback" "', argument " "2"" of type '" "SoSensorCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->setDeleteCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_setDeleteCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  SoSensorCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_setDeleteCallback" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSensor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDataSensor_setDeleteCallback" "', argument " "2"" of type '" "SoSensorCB *""'"); 
    }
  }
  (arg1)->setDeleteCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_setDeleteCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDataSensor_setDeleteCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDataSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSensor__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDataSensor_setDeleteCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDataSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSensor__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDataSensor_setDeleteCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDataSensor_setDeleteCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDataSensor::setDeleteCallback(SoSensorCB *,void *)\n"
    "    SoDataSensor::setDeleteCallback(SoSensorCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerNode" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoNode *)((SoDataSensor const *)arg1)->getTriggerNode();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerField" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoField *)((SoDataSensor const *)arg1)->getTriggerField();
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerPath" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoPath *)((SoDataSensor const *)arg1)->getTriggerPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_setTriggerPathFlag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDataSensor_setTriggerPathFlag", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_setTriggerPathFlag" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDataSensor_setTriggerPathFlag" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setTriggerPathFlag(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerPathFlag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerPathFlag" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SbBool)((SoDataSensor const *)arg1)->getTriggerPathFlag();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerOperationType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNotRec::OperationType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerOperationType" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoNotRec::OperationType)((SoDataSensor const *)arg1)->getTriggerOperationType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerIndex" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (int)((SoDataSensor const *)arg1)->getTriggerIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerFieldNumIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerFieldNumIndices" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (int)((SoDataSensor const *)arg1)->getTriggerFieldNumIndices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerGroupChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerGroupChild" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoNode *)((SoDataSensor const *)arg1)->getTriggerGroupChild();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_getTriggerReplacedGroupChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_getTriggerReplacedGroupChild" "', argument " "1"" of type '" "SoDataSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  result = (SoNode *)((SoDataSensor const *)arg1)->getTriggerReplacedGroupChild();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_trigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_trigger" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  (arg1)->trigger();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDataSensor_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_notify" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDataSensor_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDataSensor_dyingReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDataSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDataSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDataSensor_dyingReference" "', argument " "1"" of type '" "SoDataSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoDataSensor * >(argp1);
  (arg1)->dyingReference();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDataSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDataSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoFieldSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFieldSensor", 0, 0, 0)) SWIG_fail;
  result = (SoFieldSensor *)new SoFieldSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFieldSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoFieldSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFieldSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoFieldSensor *)new SoFieldSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoFieldSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoFieldSensor" "', argument " "1"" of type '" "SoFieldSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldSensor_attach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldSensor_attach", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldSensor_attach" "', argument " "1"" of type '" "SoFieldSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldSensor_attach" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->attach(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldSensor_detach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldSensor_detach" "', argument " "1"" of type '" "SoFieldSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldSensor * >(argp1);
  (arg1)->detach();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldSensor_getAttachedField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldSensor_getAttachedField" "', argument " "1"" of type '" "SoFieldSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldSensor * >(argp1);
  result = (SoField *)((SoFieldSensor const *)arg1)->getAttachedField();
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldSensor_trigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldSensor_trigger" "', argument " "1"" of type '" "SoFieldSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldSensor * >(argp1);
  (arg1)->trigger();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFieldSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFieldSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFieldSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInteractionKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInteractionKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_getTypeId" "', argument " "1"" of type '" "SoInteractionKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = ((SoInteractionKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoInteractionKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_getNodekitCatalog" "', argument " "1"" of type '" "SoInteractionKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = (SoNodekitCatalog *)((SoInteractionKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_renderCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_renderCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_renderCaching_set" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_renderCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_renderCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_renderCaching_get" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_boundingBoxCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_boundingBoxCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_boundingBoxCaching_set" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_boundingBoxCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->boundingBoxCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_boundingBoxCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_boundingBoxCaching_get" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->boundingBoxCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_renderCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_renderCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_renderCulling_set" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_renderCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_renderCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_renderCulling_get" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_pickCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_pickCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_pickCulling_set" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_pickCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->pickCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_pickCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_pickCulling_get" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->pickCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInteractionKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInteractionKit", 0, 0, 0)) SWIG_fail;
  result = (SoInteractionKit *)new SoInteractionKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInteractionKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_initClass", 0, 0, 0)) SWIG_fail;
  SoInteractionKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoPath *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_setPartAsPath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPartAsPath" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_setPartAsPath" "', argument " "3"" of type '" "SoPath *""'"); 
  }
  arg3 = reinterpret_cast< SoPath * >(argp3);
  result = (SbBool)(arg1)->setPartAsPath((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SbBool)(arg1)->setPartAsDefault((SbName const &)*arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  result = (SbBool)(arg1)->setPartAsDefault((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsDefault__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SbBool)(arg1)->setPartAsDefault((SbName const &)*arg2,(SbName const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsDefault__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPartAsDefault" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)(arg1)->setPartAsDefault((SbName const &)*arg2,(SbName const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPartAsDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInteractionKit_setPartAsDefault", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoInteractionKit_setPartAsDefault__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          void *ptr = NULL;
          _v = 1;
          
          
          
          
          if (!PyBytes_Check(argv[2]) && 
            !PyUnicode_Check(argv[2]) && 
            (SWIG_ConvertPtr(argv[2], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
          
          {
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_SoInteractionKit_setPartAsDefault__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          void *ptr = NULL;
          _v = 1;
          
          
          
          
          if (!PyBytes_Check(argv[2]) && 
            !PyUnicode_Check(argv[2]) && 
            (SWIG_ConvertPtr(argv[2], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
          
          {
            _v = 0;
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoInteractionKit_setPartAsDefault__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoInteractionKit_setPartAsDefault__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInteractionKit_setPartAsDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInteractionKit::setPartAsDefault(SbName const &,SoNode *,SbBool)\n"
    "    SoInteractionKit::setPartAsDefault(SbName const &,SoNode *)\n"
    "    SoInteractionKit::setPartAsDefault(SbName const &,SbName const &,SbBool)\n"
    "    SoInteractionKit::setPartAsDefault(SbName const &,SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoPath **arg3 = 0 ;
  SbName *arg4 = 0 ;
  SoPath **arg5 = 0 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_SoPath,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "3"" of type '" "SoPath *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "3"" of type '" "SoPath *&""'"); 
  }
  arg3 = reinterpret_cast< SoPath ** >(argp3);
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_SoPath,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "5"" of type '" "SoPath *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "5"" of type '" "SoPath *&""'"); 
  }
  arg5 = reinterpret_cast< SoPath ** >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  result = (SbBool)(arg1)->isPathSurrogateInMySubgraph((SoPath const *)arg2,*arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoPath **arg3 = 0 ;
  SbName *arg4 = 0 ;
  SoPath **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_SoPath,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "3"" of type '" "SoPath *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "3"" of type '" "SoPath *&""'"); 
  }
  arg3 = reinterpret_cast< SoPath ** >(argp3);
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_SoPath,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "5"" of type '" "SoPath *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "5"" of type '" "SoPath *&""'"); 
  }
  arg5 = reinterpret_cast< SoPath ** >(argp5);
  result = (SbBool)(arg1)->isPathSurrogateInMySubgraph((SoPath const *)arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInteractionKit_isPathSurrogateInMySubgraph" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->isPathSurrogateInMySubgraph((SoPath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_isPathSurrogateInMySubgraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoInteractionKit_isPathSurrogateInMySubgraph", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_SoPath, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) && 
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_SoPath, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoInteractionKit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_SoPath, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) && 
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_SoPath, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoInteractionKit_isPathSurrogateInMySubgraph__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoInteractionKit_isPathSurrogateInMySubgraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoInteractionKit::isPathSurrogateInMySubgraph(SoPath const *,SoPath *&,SbName &,SoPath *&,SbBool)\n"
    "    SoInteractionKit::isPathSurrogateInMySubgraph(SoPath const *,SoPath *&,SbName &,SoPath *&)\n"
    "    SoInteractionKit::isPathSurrogateInMySubgraph(SoPath const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setSwitchValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_setSwitchValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setSwitchValue" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoInteractionKit_setSwitchValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoInteractionKit::setSwitchValue(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInteractionKit_setPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteractionKit *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteractionKit_setPart", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteractionKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInteractionKit_setPart" "', argument " "1"" of type '" "SoInteractionKit *""'"); 
  }
  arg1 = reinterpret_cast< SoInteractionKit * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoInteractionKit_setPart" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  result = (SbBool)(arg1)->setPart((SbName const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoInteractionKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInteractionKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInteractionKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoCallbackList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCallbackList", 0, 0, 0)) SWIG_fail;
  result = (SoCallbackList *)new SoCallbackList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCallbackList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoCallbackList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoCallbackList" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_addCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  SoCallbackListCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_addCallback" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackList_addCallback" "', argument " "2"" of type '" "SoCallbackListCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackList_addCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_addCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  SoCallbackListCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_addCallback" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackList_addCallback" "', argument " "2"" of type '" "SoCallbackListCB *""'"); 
    }
  }
  (arg1)->addCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_addCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackList_addCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCallbackList_addCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackList_addCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackList_addCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackList::addCallback(SoCallbackListCB *,void *)\n"
    "    SoCallbackList::addCallback(SoCallbackListCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_removeCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  SoCallbackListCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_removeCallback" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackList_removeCallback" "', argument " "2"" of type '" "SoCallbackListCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallbackList_removeCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_removeCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  SoCallbackListCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_removeCallback" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallbackList_removeCallback" "', argument " "2"" of type '" "SoCallbackListCB *""'"); 
    }
  }
  (arg1)->removeCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_removeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallbackList_removeCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCallbackList_removeCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallbackList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_void__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallbackList_removeCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallbackList_removeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallbackList::removeCallback(SoCallbackListCB *,void *)\n"
    "    SoCallbackList::removeCallback(SoCallbackListCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_clearCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_clearCallbacks" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  (arg1)->clearCallbacks();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_getNumCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_getNumCallbacks" "', argument " "1"" of type '" "SoCallbackList const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  result = (int)((SoCallbackList const *)arg1)->getNumCallbacks();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallbackList_invokeCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallbackList *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallbackList_invokeCallbacks", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallbackList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallbackList_invokeCallbacks" "', argument " "1"" of type '" "SoCallbackList *""'"); 
  }
  arg1 = reinterpret_cast< SoCallbackList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallbackList_invokeCallbacks" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->invokeCallbacks(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCallbackList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCallbackList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCallbackList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec3d *)new SbVec3d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = (double *)0 ;
  double temp1[3] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec3d_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec3d *)new SbVec3d((double const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec3d" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec3d" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbVec3d *)new SbVec3d(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (SbVec3d *)new SbVec3d((SbVec3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = (SbVec3d *)new SbVec3d((SbVec3b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = (SbVec3d *)new SbVec3d((SbVec3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = (SbVec3d *)new SbVec3d((SbVec3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPPlane *arg2 = 0 ;
  SbDPPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "1"" of type '" "SbDPPlane const &""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbVec3d" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPPlane * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SbVec3d" "', argument " "3"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3d" "', argument " "3"" of type '" "SbDPPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbDPPlane * >(argp3);
  result = (SbVec3d *)new SbVec3d((SbDPPlane const &)*arg1,(SbDPPlane const &)*arg2,(SbDPPlane const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec3d", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec3d__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3d__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3d__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3d__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3d__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec3d__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SbVec3d__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbVec3d__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec3d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3d::SbVec3d()\n"
    "    SbVec3d::SbVec3d(double const [3])\n"
    "    SbVec3d::SbVec3d(double,double,double)\n"
    "    SbVec3d::SbVec3d(SbVec3f const &)\n"
    "    SbVec3d::SbVec3d(SbVec3b const &)\n"
    "    SbVec3d::SbVec3d(SbVec3s const &)\n"
    "    SbVec3d::SbVec3d(SbVec3i32 const &)\n"
    "    SbVec3d::SbVec3d(SbDPPlane const &,SbDPPlane const &,SbDPPlane const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[3] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  {
    convert_SbVec3d_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec3d *) &(arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec3d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (SbVec3d *) &(arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  SbVec3d *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec3d_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec3d_setValue" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec3d_setValue" "', argument " "5"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "5"" of type '" "SbVec3d const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3d * >(argp5);
  result = (SbVec3d *) &(arg1)->setValue((SbVec3d const &)*arg2,(SbVec3d const &)*arg3,(SbVec3d const &)*arg4,(SbVec3d const &)*arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3d *) &(arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3b * >(argp2);
  result = (SbVec3d *) &(arg1)->setValue((SbVec3b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3d *) &(arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_setValue" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3d *) &(arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3d_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3d_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3d_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3d_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3d_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec3d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbVec3d_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec3d_setValue__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3d::setValue(double const [3])\n"
    "    SbVec3d::setValue(double,double,double)\n"
    "    SbVec3d::setValue(SbVec3d const &,SbVec3d const &,SbVec3d const &,SbVec3d const &)\n"
    "    SbVec3d::setValue(SbVec3f const &)\n"
    "    SbVec3d::setValue(SbVec3b const &)\n"
    "    SbVec3d::setValue(SbVec3s const &)\n"
    "    SbVec3d::setValue(SbVec3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_getValue" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (double *)((SbVec3d const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(fff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_cross(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d_cross", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_cross" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_cross" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_cross" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = ((SbVec3d const *)arg1)->cross((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_dot" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_dot" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_dot" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (double)((SbVec3d const *)arg1)->dot((SbVec3d const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_equals" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d_equals" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d_equals" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3d_equals" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbBool)((SbVec3d const *)arg1)->equals((SbVec3d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_getClosestAxis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_getClosestAxis" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = ((SbVec3d const *)arg1)->getClosestAxis();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_length" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (double)((SbVec3d const *)arg1)->length();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_sqrLength" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (double)((SbVec3d const *)arg1)->sqrLength();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_negate" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_normalize" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (double)(arg1)->normalize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___imul__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3d *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___itruediv__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3d *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___iadd__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___iadd__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___iadd__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3d *) &(arg1)->operator +=((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___isub__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___isub__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___isub__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3d *) &(arg1)->operator -=((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___neg__" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = ((SbVec3d const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_toString" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = ((SbVec3d const *)arg1)->toString();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_fromString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d_fromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_fromString" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->fromString((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d_output" "', argument " "1"" of type '" "SbVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec3d const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___add__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___add__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___add__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = SbVec3d___add__(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___sub__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___sub__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___sub__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = SbVec3d___sub__(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___mul__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3d___mul____SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___mul__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = SbVec3d___mul____SWIG_1(arg1,(SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3d___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3d___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3d___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___rmul__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3d___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___div__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3d___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___truediv__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___truediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec3d___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___eq__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___eq__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___eq__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (int)SbVec3d___eq__(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec3d___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___nq__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3d___nq__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3d___nq__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (int)SbVec3d___nq__(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___getitem__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)SbVec3d___getitem__(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3d___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3d___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3d___setitem__" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3d___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3d___setitem__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  SbVec3d___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3d" "', argument " "1"" of type '" "SbVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbDPViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbDPViewVolume", 0, 0, 0)) SWIG_fail;
  result = (SbDPViewVolume *)new SbDPViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPViewVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbDPViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDPViewVolume" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getMatrices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  SbDPMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getMatrices", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getMatrices" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_getMatrices" "', argument " "2"" of type '" "SbDPMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_getMatrices" "', argument " "2"" of type '" "SbDPMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPViewVolume_getMatrices" "', argument " "3"" of type '" "SbDPMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_getMatrices" "', argument " "3"" of type '" "SbDPMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbDPMatrix * >(argp3);
  ((SbDPViewVolume const *)arg1)->getMatrices(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getMatrix" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = ((SbDPViewVolume const *)arg1)->getMatrix();
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getCameraSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getCameraSpaceMatrix" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = ((SbDPViewVolume const *)arg1)->getCameraSpaceMatrix();
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_projectPointToLine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbDPLine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPLine,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  arg3 = reinterpret_cast< SbDPLine * >(argp3);
  ((SbDPViewVolume const *)arg1)->projectPointToLine((SbVec2d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_projectPointToLine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectPointToLine" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  ((SbDPViewVolume const *)arg1)->projectPointToLine((SbVec2d const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_projectPointToLine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPViewVolume_projectPointToLine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbDPLine, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPViewVolume_projectPointToLine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbDPViewVolume_projectPointToLine__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPViewVolume_projectPointToLine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPViewVolume::projectPointToLine(SbVec2d const &,SbDPLine &) const\n"
    "    SbDPViewVolume::projectPointToLine(SbVec2d const &,SbVec3d &,SbVec3d &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_projectToScreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_projectToScreen", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_projectToScreen" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_projectToScreen" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectToScreen" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPViewVolume_projectToScreen" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectToScreen" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbDPViewVolume const *)arg1)->projectToScreen((SbVec3d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbPlane result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getPlane", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getPlane" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_getPlane" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((SbDPViewVolume const *)arg1)->getPlane(arg2);
  resultobj = SWIG_NewPointerObj((new SbPlane(result)), SWIGTYPE_p_SbPlane, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getSightPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getSightPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getSightPoint" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_getSightPoint" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((SbDPViewVolume const *)arg1)->getSightPoint(arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getPlanePoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getPlanePoint", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getPlanePoint" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_getPlanePoint" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPViewVolume_getPlanePoint" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_getPlanePoint" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  result = ((SbDPViewVolume const *)arg1)->getPlanePoint(arg2,(SbVec2d const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getAlignRotation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbDPRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getAlignRotation" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_getAlignRotation" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = ((SbDPViewVolume const *)arg1)->getAlignRotation(arg2);
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getAlignRotation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPRotation result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getAlignRotation" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = ((SbDPViewVolume const *)arg1)->getAlignRotation();
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getAlignRotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getAlignRotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbDPViewVolume_getAlignRotation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbDPViewVolume_getAlignRotation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPViewVolume_getAlignRotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPViewVolume::getAlignRotation(SbBool) const\n"
    "    SbDPViewVolume::getAlignRotation() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getWorldToScreenScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getWorldToScreenScale", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getWorldToScreenScale" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_getWorldToScreenScale" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_getWorldToScreenScale" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_getWorldToScreenScale" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)((SbDPViewVolume const *)arg1)->getWorldToScreenScale((SbVec3d const &)*arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_projectBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_projectBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_projectBox" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_projectBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_projectBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = ((SbDPViewVolume const *)arg1)->projectBox((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_narrow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SbDPViewVolume result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_narrow" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_narrow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_narrow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPViewVolume_narrow" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPViewVolume_narrow" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = ((SbDPViewVolume const *)arg1)->narrow(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new SbDPViewVolume(result)), SWIGTYPE_p_SbDPViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_narrow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_narrow" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_narrow" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_narrow" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = ((SbDPViewVolume const *)arg1)->narrow((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbDPViewVolume(result)), SWIGTYPE_p_SbDPViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_narrow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPViewVolume_narrow", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPViewVolume_narrow__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbDPViewVolume_narrow__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPViewVolume_narrow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPViewVolume::narrow(double,double,double,double) const\n"
    "    SbDPViewVolume::narrow(SbBox3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_ortho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_ortho", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_ortho" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_ortho" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_ortho" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPViewVolume_ortho" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPViewVolume_ortho" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbDPViewVolume_ortho" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbDPViewVolume_ortho" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_perspective(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_perspective", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_perspective" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_perspective" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_perspective" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPViewVolume_perspective" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPViewVolume_perspective" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->perspective(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_frustum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_frustum", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_frustum" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_frustum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_frustum" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPViewVolume_frustum" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPViewVolume_frustum" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbDPViewVolume_frustum" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbDPViewVolume_frustum" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_rotateCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_rotateCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_rotateCamera" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_rotateCamera" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_rotateCamera" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  (arg1)->rotateCamera((SbDPRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_translateCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_translateCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_translateCamera" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_translateCamera" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_translateCamera" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->translateCamera((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_zVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_zVector" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = ((SbDPViewVolume const *)arg1)->zVector();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_zNarrow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbDPViewVolume result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_zNarrow", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_zNarrow" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_zNarrow" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPViewVolume_zNarrow" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = ((SbDPViewVolume const *)arg1)->zNarrow(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbDPViewVolume(result)), SWIGTYPE_p_SbDPViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_scale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_scale" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_scaleWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_scaleWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_scaleWidth" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_scaleWidth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scaleWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_scaleHeight" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPViewVolume_scaleHeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getProjectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPViewVolume::ProjectionType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getProjectionType" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (SbDPViewVolume::ProjectionType)((SbDPViewVolume const *)arg1)->getProjectionType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getProjectionPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getProjectionPoint" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (SbVec3d *) &((SbDPViewVolume const *)arg1)->getProjectionPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getProjectionDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getProjectionDirection" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (SbVec3d *) &((SbDPViewVolume const *)arg1)->getProjectionDirection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getNearDist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getNearDist" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (double)((SbDPViewVolume const *)arg1)->getNearDist();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getWidth" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (double)((SbDPViewVolume const *)arg1)->getWidth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getHeight" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (double)((SbDPViewVolume const *)arg1)->getHeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getDepth" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = (double)((SbDPViewVolume const *)arg1)->getDepth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_output" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbDPViewVolume const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getViewVolumePlanes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbPlane *arg2 = (SbPlane *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_getViewVolumePlanes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getViewVolumePlanes" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_getViewVolumePlanes" "', argument " "2"" of type '" "SbPlane [6]""'"); 
  } 
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  ((SbDPViewVolume const *)arg1)->getViewVolumePlanes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_transform" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_transform" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_transform" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  (arg1)->transform((SbDPMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_getViewUp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_getViewUp" "', argument " "1"" of type '" "SbDPViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  result = ((SbDPViewVolume const *)arg1)->getViewUp();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPViewVolume_copyValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPViewVolume *arg1 = 0 ;
  SbViewVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPViewVolume_copyValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPViewVolume_copyValues" "', argument " "1"" of type '" "SbDPViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbDPViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewVolume,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPViewVolume_copyValues" "', argument " "2"" of type '" "SbViewVolume &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPViewVolume_copyValues" "', argument " "2"" of type '" "SbViewVolume &""'"); 
  }
  arg2 = reinterpret_cast< SbViewVolume * >(argp2);
  (arg1)->copyValues(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbDPViewVolume_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDPViewVolume, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDPViewVolume_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbViewVolume", 0, 0, 0)) SWIG_fail;
  result = (SbViewVolume *)new SbViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbViewVolume" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getMatrices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getMatrices", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getMatrices" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_getMatrices" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_getMatrices" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewVolume_getMatrices" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_getMatrices" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SbViewVolume const *)arg1)->getMatrices(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getMatrix" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = ((SbViewVolume const *)arg1)->getMatrix();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getCameraSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getCameraSpaceMatrix" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = ((SbViewVolume const *)arg1)->getCameraSpaceMatrix();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbPlane result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getPlane", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getPlane" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_getPlane" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SbViewVolume const *)arg1)->getPlane(arg2);
  resultobj = SWIG_NewPointerObj((new SbPlane(result)), SWIGTYPE_p_SbPlane, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getSightPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getSightPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getSightPoint" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_getSightPoint" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SbViewVolume const *)arg1)->getSightPoint(arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getPlanePoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getPlanePoint", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getPlanePoint" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_getPlanePoint" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewVolume_getPlanePoint" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_getPlanePoint" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = ((SbViewVolume const *)arg1)->getPlanePoint(arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getAlignRotation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getAlignRotation" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_getAlignRotation" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = ((SbViewVolume const *)arg1)->getAlignRotation(arg2);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getAlignRotation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbRotation result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getAlignRotation" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = ((SbViewVolume const *)arg1)->getAlignRotation();
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getAlignRotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewVolume_getAlignRotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbViewVolume_getAlignRotation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbViewVolume_getAlignRotation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewVolume_getAlignRotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewVolume::getAlignRotation(SbBool) const\n"
    "    SbViewVolume::getAlignRotation() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getWorldToScreenScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getWorldToScreenScale", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getWorldToScreenScale" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_getWorldToScreenScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_getWorldToScreenScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_getWorldToScreenScale" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (float)((SbViewVolume const *)arg1)->getWorldToScreenScale((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projectBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_projectBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projectBox" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_projectBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_projectBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = ((SbViewVolume const *)arg1)->projectBox((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_narrow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_narrow" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_narrow" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_narrow" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewVolume_narrow" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewVolume_narrow" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = ((SbViewVolume const *)arg1)->narrow(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_narrow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_narrow" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_narrow" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_narrow" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = ((SbViewVolume const *)arg1)->narrow((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_narrow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewVolume_narrow", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbViewVolume_narrow__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbViewVolume_narrow__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewVolume_narrow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewVolume::narrow(float,float,float,float) const\n"
    "    SbViewVolume::narrow(SbBox3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_ortho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_ortho", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_ortho" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_ortho" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_ortho" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewVolume_ortho" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewVolume_ortho" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbViewVolume_ortho" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbViewVolume_ortho" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  (arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_perspective(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_perspective", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_perspective" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_perspective" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_perspective" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewVolume_perspective" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewVolume_perspective" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->perspective(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_frustum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_frustum", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_frustum" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_frustum" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_frustum" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbViewVolume_frustum" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbViewVolume_frustum" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbViewVolume_frustum" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbViewVolume_frustum" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  (arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_rotateCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_rotateCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_rotateCamera" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_rotateCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_rotateCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  (arg1)->rotateCamera((SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_translateCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_translateCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_translateCamera" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->translateCamera((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_zVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_zVector" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = ((SbViewVolume const *)arg1)->zVector();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_zNarrow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbViewVolume result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_zNarrow", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_zNarrow" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_zNarrow" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbViewVolume_zNarrow" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = ((SbViewVolume const *)arg1)->zNarrow(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_scale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_scale" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_scaleWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_scaleWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_scaleWidth" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_scaleWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_scaleHeight" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getProjectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume::ProjectionType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getProjectionType" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbViewVolume::ProjectionType)((SbViewVolume const *)arg1)->getProjectionType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getProjectionPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getProjectionPoint" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *) &((SbViewVolume const *)arg1)->getProjectionPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getProjectionDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getProjectionDirection" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *) &((SbViewVolume const *)arg1)->getProjectionDirection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getNearDist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getNearDist" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float)((SbViewVolume const *)arg1)->getNearDist();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getWidth" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float)((SbViewVolume const *)arg1)->getWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getHeight" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float)((SbViewVolume const *)arg1)->getHeight();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getDepth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getDepth" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float)((SbViewVolume const *)arg1)->getDepth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_output" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbViewVolume const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getViewVolumePlanes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbPlane *arg2 = (SbPlane *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_getViewVolumePlanes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getViewVolumePlanes" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_getViewVolumePlanes" "', argument " "2"" of type '" "SbPlane [6]""'"); 
  } 
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  ((SbViewVolume const *)arg1)->getViewVolumePlanes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_transform" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  (arg1)->transform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getViewUp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getViewUp" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = ((SbViewVolume const *)arg1)->getViewUp();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_intersect" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbViewVolume const *)arg1)->intersect((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_intersect" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewVolume_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersect" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbViewVolume_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SbViewVolume const *)arg1)->intersect((SbVec3f const &)*arg2,(SbVec3f const &)*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_intersect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_intersect" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersect" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)((SbViewVolume const *)arg1)->intersect((SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbViewVolume_intersect", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbViewVolume_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbViewVolume_intersect__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbViewVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbViewVolume_intersect__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbViewVolume_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbViewVolume::intersect(SbVec3f const &) const\n"
    "    SbViewVolume::intersect(SbVec3f const &,SbVec3f const &,SbVec3f &) const\n"
    "    SbViewVolume::intersect(SbBox3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_intersectionBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBox3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_intersectionBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_intersectionBox" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_intersectionBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_intersectionBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = ((SbViewVolume const *)arg1)->intersectionBox((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbBox3f(result)), SWIGTYPE_p_SbBox3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_outsideTest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_outsideTest", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_outsideTest" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_outsideTest" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_outsideTest" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbViewVolume_outsideTest" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_outsideTest" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbViewVolume_outsideTest" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_outsideTest" "', argument " "4"" of type '" "SbVec3f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SbViewVolume const *)arg1)->outsideTest((SbPlane const &)*arg2,(SbVec3f const &)*arg3,(SbVec3f const &)*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_getDPViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_getDPViewVolume" "', argument " "1"" of type '" "SbViewVolume const *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbDPViewVolume *) &((SbViewVolume const *)arg1)->getDPViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbViewVolume::ProjectionType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_type_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_type_set" "', argument " "2"" of type '" "SbViewVolume::ProjectionType""'");
  } 
  arg2 = static_cast< SbViewVolume::ProjectionType >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume::ProjectionType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_type_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbViewVolume::ProjectionType) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projPoint_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_projPoint_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projPoint_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_projPoint_set" "', argument " "2"" of type '" "SbVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  if (arg1) (arg1)->projPoint = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projPoint_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projPoint_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *)& ((arg1)->projPoint);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projDir_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_projDir_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projDir_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_projDir_set" "', argument " "2"" of type '" "SbVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  if (arg1) (arg1)->projDir = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projDir_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projDir_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *)& ((arg1)->projDir);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_nearDist_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_nearDist_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_nearDist_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_nearDist_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->nearDist = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_nearDist_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_nearDist_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float) ((arg1)->nearDist);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_nearToFar_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_nearToFar_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_nearToFar_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbViewVolume_nearToFar_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->nearToFar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_nearToFar_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_nearToFar_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (float) ((arg1)->nearToFar);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_llf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_llf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_llf_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_llf_set" "', argument " "2"" of type '" "SbVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  if (arg1) (arg1)->llf = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_llf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_llf_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *)& ((arg1)->llf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_lrf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_lrf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_lrf_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_lrf_set" "', argument " "2"" of type '" "SbVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  if (arg1) (arg1)->lrf = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_lrf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_lrf_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *)& ((arg1)->lrf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_ulf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_ulf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_ulf_set" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_ulf_set" "', argument " "2"" of type '" "SbVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  if (arg1) (arg1)->ulf = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_ulf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_ulf_get" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  result = (SbVec3f *)& ((arg1)->ulf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projectPointToLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_projectPointToLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projectPointToLine" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_projectPointToLine" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (PyObject *)SbViewVolume_projectPointToLine(arg1,(SbVec2f const &)*arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbViewVolume_projectToScreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbViewVolume *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbViewVolume_projectToScreen", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbViewVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbViewVolume_projectToScreen" "', argument " "1"" of type '" "SbViewVolume *""'"); 
  }
  arg1 = reinterpret_cast< SbViewVolume * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbViewVolume_projectToScreen" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbViewVolume_projectToScreen" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (PyObject *)SbViewVolume_projectToScreen(arg1,(SbVec3f const &)*arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbViewVolume_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbViewVolume, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbViewVolume_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec3f *)new SoSFVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec3f" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_getTypeId" "', argument " "1"" of type '" "SoSFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  result = ((SoSFVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_copyFrom" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_isSame" "', argument " "1"" of type '" "SoSFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec3f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_getValue" "', argument " "1"" of type '" "SoSFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  result = (SbVec3f *) &((SoSFVec3f const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_setValue" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f___eq__" "', argument " "1"" of type '" "SoSFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f___eq__" "', argument " "2"" of type '" "SoSFVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3f___eq__" "', argument " "2"" of type '" "SoSFVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  result = (int)((SoSFVec3f const *)arg1)->operator ==((SoSFVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f___ne__" "', argument " "1"" of type '" "SoSFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f___ne__" "', argument " "2"" of type '" "SoSFVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3f___ne__" "', argument " "2"" of type '" "SoSFVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  result = (int)((SoSFVec3f const *)arg1)->operator !=((SoSFVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_setValue" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec3f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec3f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec3f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_setValue" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3f *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3f_setValue" "', argument " "1"" of type '" "SoSFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3f_setValue" "', argument " "2"" of type '" "SoSFVec3f const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  SoSFVec3f_setValue__SWIG_3(arg1,(SoSFVec3f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec3f_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFVec3f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFVec3f_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec3f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec3f::setValue(SbVec3f const &)\n"
    "    SoSFVec3f::setValue(float,float,float)\n"
    "    SoSFVec3f::setValue(float const [3])\n"
    "    SoSFVec3f::setValue(SoSFVec3f const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScale_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScale::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_getTypeId" "', argument " "1"" of type '" "SoScale const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  result = ((SoScale const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_initClass", 0, 0, 0)) SWIG_fail;
  SoScale::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScale", 0, 0, 0)) SWIG_fail;
  result = (SoScale *)new SoScale();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScale, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_scaleFactor_set" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_scaleFactor_get" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_doAction" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_callback" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_GLRender" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_getBoundingBox" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_getMatrix" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_pick" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale_getPrimitiveCount" "', argument " "1"" of type '" "SoScale *""'"); 
  }
  arg1 = reinterpret_cast< SoScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScale, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getTypeId" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = ((SoDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_isActive_set" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_isActive_get" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_callback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_GLRender" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_rayPick" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_search" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_write" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getPrimitiveCount" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setProjectorEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setProjectorEpsilon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setProjectorEpsilon" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDragger_setProjectorEpsilon" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setProjectorEpsilon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getProjectorEpsilon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getProjectorEpsilon" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (float)((SoDragger const *)arg1)->getProjectorEpsilon();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addStartCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addStartCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addStartCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->addStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeStartCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removeStartCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeStartCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->removeStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addMotionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addMotionCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addMotionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addMotionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addMotionCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->addMotionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeMotionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeMotionCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removeMotionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeMotionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeMotionCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->removeMotionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addFinishCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addFinishCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addFinishCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->addFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeFinishCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removeFinishCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeFinishCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->removeFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addValueChangedCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addValueChangedCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addValueChangedCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addValueChangedCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addValueChangedCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->addValueChangedCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeValueChangedCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removeValueChangedCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeValueChangedCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->removeValueChangedCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setMinGesture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setMinGesture", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setMinGesture" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDragger_setMinGesture" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMinGesture(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getMinGesture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getMinGesture" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (int)((SoDragger const *)arg1)->getMinGesture();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_enableValueChangedCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_enableValueChangedCallbacks", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_enableValueChangedCallbacks" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDragger_enableValueChangedCallbacks" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbBool)(arg1)->enableValueChangedCallbacks(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getMotionMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getMotionMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SbMatrix *) &(arg1)->getMotionMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addOtherEventCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addOtherEventCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addOtherEventCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addOtherEventCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_addOtherEventCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->addOtherEventCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeOtherEventCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removeOtherEventCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeOtherEventCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDraggerCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoDragger__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "2"" of type '" "SoDraggerCB *""'"); 
    }
  }
  (arg1)->removeOtherEventCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_registerChildDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDragger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_registerChildDragger", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_registerChildDragger" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_registerChildDragger" "', argument " "2"" of type '" "SoDragger *""'"); 
  }
  arg2 = reinterpret_cast< SoDragger * >(argp2);
  (arg1)->registerChildDragger(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_unregisterChildDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDragger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_unregisterChildDragger", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_unregisterChildDragger" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_unregisterChildDragger" "', argument " "2"" of type '" "SoDragger *""'"); 
  }
  arg2 = reinterpret_cast< SoDragger * >(argp2);
  (arg1)->unregisterChildDragger(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_registerChildDraggerMovingIndependently(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDragger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_registerChildDraggerMovingIndependently", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_registerChildDraggerMovingIndependently" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_registerChildDraggerMovingIndependently" "', argument " "2"" of type '" "SoDragger *""'"); 
  }
  arg2 = reinterpret_cast< SoDragger * >(argp2);
  (arg1)->registerChildDraggerMovingIndependently(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_unregisterChildDraggerMovingIndependently(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDragger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_unregisterChildDraggerMovingIndependently", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_unregisterChildDraggerMovingIndependently" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_unregisterChildDraggerMovingIndependently" "', argument " "2"" of type '" "SoDragger *""'"); 
  }
  arg2 = reinterpret_cast< SoDragger * >(argp2);
  (arg1)->unregisterChildDraggerMovingIndependently(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getLocalToWorldMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getLocalToWorldMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (arg1)->getLocalToWorldMatrix();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getWorldToLocalMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getWorldToLocalMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (arg1)->getWorldToLocalMatrix();
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getLocalStartingPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getLocalStartingPoint" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (arg1)->getLocalStartingPoint();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getWorldStartingPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getWorldStartingPoint" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (arg1)->getWorldStartingPoint();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getPartToLocalMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getPartToLocalMatrix", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getPartToLocalMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_getPartToLocalMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getPartToLocalMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_getPartToLocalMatrix" "', argument " "4"" of type '" "SbMatrix &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getPartToLocalMatrix" "', argument " "4"" of type '" "SbMatrix &""'"); 
  }
  arg4 = reinterpret_cast< SbMatrix * >(argp4);
  (arg1)->getPartToLocalMatrix((SbName const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_transformMatrixLocalToWorld(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_transformMatrixLocalToWorld", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_transformMatrixLocalToWorld" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_transformMatrixLocalToWorld" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixLocalToWorld" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_transformMatrixLocalToWorld" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixLocalToWorld" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  (arg1)->transformMatrixLocalToWorld((SbMatrix const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_transformMatrixWorldToLocal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_transformMatrixWorldToLocal", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_transformMatrixWorldToLocal" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_transformMatrixWorldToLocal" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixWorldToLocal" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_transformMatrixWorldToLocal" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixWorldToLocal" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  (arg1)->transformMatrixWorldToLocal((SbMatrix const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_transformMatrixToLocalSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  SbName *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_transformMatrixToLocalSpace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_transformMatrixToLocalSpace" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_transformMatrixToLocalSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixToLocalSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_transformMatrixToLocalSpace" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_transformMatrixToLocalSpace" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  (arg1)->transformMatrixToLocalSpace((SbMatrix const &)*arg2,*arg3,(SbName const &)*arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setMotionMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setMotionMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setMotionMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setMotionMatrix" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_setMotionMatrix" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setMotionMatrix((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_valueChanged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_valueChanged" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  (arg1)->valueChanged();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getStartMotionMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getStartMotionMatrix" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SbMatrix *) &(arg1)->getStartMotionMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_saveStartParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_saveStartParameters" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  (arg1)->saveStartParameters();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getPickPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getPickPath" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoPath *)((SoDragger const *)arg1)->getPickPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getEvent" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoEvent *)((SoDragger const *)arg1)->getEvent();
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_createPathToThis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_createPathToThis" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoPath *)(arg1)->createPathToThis();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getSurrogatePartPickedOwner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getSurrogatePartPickedOwner" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoPath *)((SoDragger const *)arg1)->getSurrogatePartPickedOwner();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getSurrogatePartPickedName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getSurrogatePartPickedName" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SbName *) &((SoDragger const *)arg1)->getSurrogatePartPickedName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getSurrogatePartPickedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getSurrogatePartPickedPath" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoPath *)((SoDragger const *)arg1)->getSurrogatePartPickedPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setStartingPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoPickedPoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setStartingPoint" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setStartingPoint" "', argument " "2"" of type '" "SoPickedPoint const *""'"); 
  }
  arg2 = reinterpret_cast< SoPickedPoint * >(argp2);
  (arg1)->setStartingPoint((SoPickedPoint const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setStartingPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setStartingPoint" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setStartingPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_setStartingPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setStartingPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setStartingPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_setStartingPoint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_setStartingPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_setStartingPoint__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_setStartingPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::setStartingPoint(SoPickedPoint const *)\n"
    "    SoDragger::setStartingPoint(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_getViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getViewVolume" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SbViewVolume *) &(arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbViewVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setViewVolume", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setViewVolume" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewVolume,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewVolume * >(argp2);
  (arg1)->setViewVolume((SbViewVolume const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getViewportRegion" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SbViewportRegion *) &(arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setViewportRegion" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoHandleEventAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getHandleEventAction" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoHandleEventAction *)((SoDragger const *)arg1)->getHandleEventAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setHandleEventAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setHandleEventAction" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setHandleEventAction" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->setHandleEventAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setTempPathToThis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setTempPathToThis", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setTempPathToThis" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_setTempPathToThis" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->setTempPathToThis((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_grabEventsSetup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_grabEventsSetup" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  (arg1)->grabEventsSetup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_grabEventsCleanup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_grabEventsCleanup" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  (arg1)->grabEventsCleanup();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_workFieldsIntoTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_workFieldsIntoTransform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_workFieldsIntoTransform" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_workFieldsIntoTransform" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_workFieldsIntoTransform" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->workFieldsIntoTransform(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setFrontOnProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  SoDragger::ProjectorFrontSetting arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_setFrontOnProjector", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_setFrontOnProjector" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDragger_setFrontOnProjector" "', argument " "2"" of type '" "SoDragger::ProjectorFrontSetting""'");
  } 
  arg2 = static_cast< SoDragger::ProjectorFrontSetting >(val2);
  (arg1)->setFrontOnProjector(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getFrontOnProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger::ProjectorFrontSetting result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getFrontOnProjector" "', argument " "1"" of type '" "SoDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  result = (SoDragger::ProjectorFrontSetting)((SoDragger const *)arg1)->getFrontOnProjector();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_setMinScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoDragger_setMinScale" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  SoDragger::setMinScale(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getMinScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_getMinScale", 0, 0, 0)) SWIG_fail;
  result = (float)SoDragger::getMinScale();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_workValuesIntoTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  SbVec3f *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_workValuesIntoTransform", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_workValuesIntoTransform" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "2"" of type '" "SbVec3f const *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "3"" of type '" "SbRotation const *""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "4"" of type '" "SbVec3f const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SbRotation, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "5"" of type '" "SbRotation const *""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoDragger_workValuesIntoTransform" "', argument " "6"" of type '" "SbVec3f const *""'"); 
  }
  arg6 = reinterpret_cast< SbVec3f * >(argp6);
  SoDragger::workValuesIntoTransform(*arg1,(SbVec3f const *)arg2,(SbRotation const *)arg3,(SbVec3f const *)arg4,(SbRotation const *)arg5,(SbVec3f const *)arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getTransformFast__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  SbVec3f *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getTransformFast" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_getTransformFast" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_getTransformFast" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_getTransformFast" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDragger_getTransformFast" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoDragger_getTransformFast" "', argument " "6"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "6"" of type '" "SbVec3f const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3f * >(argp6);
  SoDragger::getTransformFast(*arg1,*arg2,*arg3,*arg4,*arg5,(SbVec3f const &)*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getTransformFast__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  SbRotation *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_getTransformFast" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "1"" of type '" "SbMatrix &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_getTransformFast" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "2"" of type '" "SbVec3f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_getTransformFast" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_getTransformFast" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDragger_getTransformFast" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_getTransformFast" "', argument " "5"" of type '" "SbRotation &""'"); 
  }
  arg5 = reinterpret_cast< SbRotation * >(argp5);
  SoDragger::getTransformFast(*arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_getTransformFast(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_getTransformFast", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoDragger_getTransformFast__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SoDragger_getTransformFast__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_getTransformFast'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::getTransformFast(SbMatrix &,SbVec3f &,SbRotation &,SbVec3f &,SbRotation &,SbVec3f const &)\n"
    "    SoDragger::getTransformFast(SbMatrix &,SbVec3f &,SbRotation &,SbVec3f &,SbRotation &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendTranslation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendTranslation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendTranslation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_appendTranslation" "', argument " "3"" of type '" "SbMatrix const *""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  result = SoDragger::appendTranslation((SbMatrix const &)*arg1,(SbVec3f const &)*arg2,(SbMatrix const *)arg3);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendTranslation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendTranslation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendTranslation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = SoDragger::appendTranslation((SbMatrix const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendTranslation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_appendTranslation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_appendTranslation__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbMatrix, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoDragger_appendTranslation__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_appendTranslation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::appendTranslation(SbMatrix const &,SbVec3f const &,SbMatrix const *)\n"
    "    SoDragger::appendTranslation(SbMatrix const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendScale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendScale" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_appendScale" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_appendScale" "', argument " "4"" of type '" "SbMatrix const *""'"); 
  }
  arg4 = reinterpret_cast< SbMatrix * >(argp4);
  result = SoDragger::appendScale((SbMatrix const &)*arg1,(SbVec3f const &)*arg2,(SbVec3f const &)*arg3,(SbMatrix const *)arg4);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendScale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendScale" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_appendScale" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendScale" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = SoDragger::appendScale((SbMatrix const &)*arg1,(SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendScale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_appendScale", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoDragger_appendScale__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbMatrix, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoDragger_appendScale__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_appendScale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::appendScale(SbMatrix const &,SbVec3f const &,SbVec3f const &,SbMatrix const *)\n"
    "    SoDragger::appendScale(SbMatrix const &,SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendRotation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_appendRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbMatrix, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDragger_appendRotation" "', argument " "4"" of type '" "SbMatrix const *""'"); 
  }
  arg4 = reinterpret_cast< SbMatrix * >(argp4);
  result = SoDragger::appendRotation((SbMatrix const &)*arg1,(SbRotation const &)*arg2,(SbVec3f const &)*arg3,(SbMatrix const *)arg4);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendRotation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbMatrix result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_appendRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "1"" of type '" "SbMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragger_appendRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDragger_appendRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDragger_appendRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = SoDragger::appendRotation((SbMatrix const &)*arg1,(SbRotation const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_appendRotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_appendRotation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoDragger_appendRotation__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbMatrix, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoDragger_appendRotation__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_appendRotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::appendRotation(SbMatrix const &,SbRotation const &,SbVec3f const &,SbMatrix const *)\n"
    "    SoDragger::appendRotation(SbMatrix const &,SbRotation const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragger_initClasses", 0, 0, 0)) SWIG_fail;
  SoDragger::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addStartCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_addStartCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addStartCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_addStartCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_addStartCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_addStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_addStartCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_addStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_addStartCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_addStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::addStartCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::addStartCallback(SoDraggerCB *)\n"
    "    SoDragger::addStartCallback(PyObject *,PyObject *)\n"
    "    SoDragger::addStartCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeStartCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_removeStartCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeStartCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeStartCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_removeStartCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_removeStartCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_removeStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_removeStartCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_removeStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_removeStartCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_removeStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::removeStartCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::removeStartCallback(SoDraggerCB *)\n"
    "    SoDragger::removeStartCallback(PyObject *,PyObject *)\n"
    "    SoDragger::removeStartCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_addMotionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_addMotionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addMotionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_addMotionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addMotionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_addMotionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_addMotionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_addMotionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_addMotionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_addMotionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_addMotionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::addMotionCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::addMotionCallback(SoDraggerCB *)\n"
    "    SoDragger::addMotionCallback(PyObject *,PyObject *)\n"
    "    SoDragger::addMotionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeMotionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_removeMotionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeMotionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeMotionCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_removeMotionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeMotionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_removeMotionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_removeMotionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_removeMotionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_removeMotionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_removeMotionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_removeMotionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::removeMotionCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::removeMotionCallback(SoDraggerCB *)\n"
    "    SoDragger::removeMotionCallback(PyObject *,PyObject *)\n"
    "    SoDragger::removeMotionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_addFinishCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_addFinishCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addFinishCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_addFinishCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_addFinishCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_addFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_addFinishCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_addFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_addFinishCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_addFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::addFinishCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::addFinishCallback(SoDraggerCB *)\n"
    "    SoDragger::addFinishCallback(PyObject *,PyObject *)\n"
    "    SoDragger::addFinishCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeFinishCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_removeFinishCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeFinishCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeFinishCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_removeFinishCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_removeFinishCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_removeFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_removeFinishCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_removeFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_removeFinishCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_removeFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::removeFinishCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::removeFinishCallback(SoDraggerCB *)\n"
    "    SoDragger::removeFinishCallback(PyObject *,PyObject *)\n"
    "    SoDragger::removeFinishCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_addValueChangedCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_addValueChangedCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addValueChangedCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_addValueChangedCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addValueChangedCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_addValueChangedCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_addValueChangedCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_addValueChangedCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_addValueChangedCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_addValueChangedCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_addValueChangedCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::addValueChangedCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::addValueChangedCallback(SoDraggerCB *)\n"
    "    SoDragger::addValueChangedCallback(PyObject *,PyObject *)\n"
    "    SoDragger::addValueChangedCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeValueChangedCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_removeValueChangedCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeValueChangedCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeValueChangedCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_removeValueChangedCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeValueChangedCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_removeValueChangedCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_removeValueChangedCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_removeValueChangedCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_removeValueChangedCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_removeValueChangedCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_removeValueChangedCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::removeValueChangedCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::removeValueChangedCallback(SoDraggerCB *)\n"
    "    SoDragger::removeValueChangedCallback(PyObject *,PyObject *)\n"
    "    SoDragger::removeValueChangedCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_addOtherEventCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_addOtherEventCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addOtherEventCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_addOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_addOtherEventCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_addOtherEventCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_addOtherEventCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_addOtherEventCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_addOtherEventCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_addOtherEventCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_addOtherEventCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_addOtherEventCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::addOtherEventCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::addOtherEventCallback(SoDraggerCB *)\n"
    "    SoDragger::addOtherEventCallback(PyObject *,PyObject *)\n"
    "    SoDragger::addOtherEventCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeOtherEventCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoDragger_removeOtherEventCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeOtherEventCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoDragger *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragger_removeOtherEventCallback" "', argument " "1"" of type '" "SoDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragger * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoDragger_removeOtherEventCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragger_removeOtherEventCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDragger_removeOtherEventCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoDragger_removeOtherEventCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoDragger_removeOtherEventCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoDragger__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoDragger_removeOtherEventCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoDragger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoDragger_removeOtherEventCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDragger_removeOtherEventCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDragger::removeOtherEventCallback(SoDraggerCB *,void *)\n"
    "    SoDragger::removeOtherEventCallback(SoDraggerCB *)\n"
    "    SoDragger::removeOtherEventCallback(PyObject *,PyObject *)\n"
    "    SoDragger::removeOtherEventCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoSFRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFRotation", 0, 0, 0)) SWIG_fail;
  result = (SoSFRotation *)new SoSFRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFRotation" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFRotation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_getTypeId" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  result = ((SoSFRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_copyFrom" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_isSame" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFRotation const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_getValue" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  result = (SbRotation *) &((SoSFRotation const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_setValue" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  (arg1)->setValue((SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation___eq__" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation___eq__" "', argument " "2"" of type '" "SoSFRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation___eq__" "', argument " "2"" of type '" "SoSFRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  result = (int)((SoSFRotation const *)arg1)->operator ==((SoSFRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFRotation___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation___ne__" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation___ne__" "', argument " "2"" of type '" "SoSFRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation___ne__" "', argument " "2"" of type '" "SoSFRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  result = (int)((SoSFRotation const *)arg1)->operator !=((SoSFRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoSFRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  {
    arg2 = new SbVec3f();
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_getValue" "', argument " "1"" of type '" "SoSFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFRotation_getValue" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation_getValue" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ((SoSFRotation const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbVec3f, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFRotation_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFRotation_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFRotation_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFRotation_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFRotation::getValue() const\n"
    "    SoSFRotation::getValue(SbVec3f &,float &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_setValue" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFRotation_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFRotation_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_setValue" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_setValue" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFRotation *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFRotation_setValue" "', argument " "1"" of type '" "SoSFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoSFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFRotation_setValue" "', argument " "2"" of type '" "SoSFRotation const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  SoSFRotation_setValue__SWIG_4(arg1,(SoSFRotation const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFRotation_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFRotation_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFRotation_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFRotation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFRotation_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFRotation_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFRotation_setValue__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFRotation_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFRotation_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFRotation::setValue(SbRotation const &)\n"
    "    SoSFRotation::setValue(float const,float const,float const,float const)\n"
    "    SoSFRotation::setValue(float const [4])\n"
    "    SoSFRotation::setValue(SbVec3f const &,float const)\n"
    "    SoSFRotation::setValue(SoSFRotation const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCenterballDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCenterballDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_getTypeId" "', argument " "1"" of type '" "SoCenterballDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  result = ((SoCenterballDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoCenterballDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoCenterballDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoCenterballDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoCenterballDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCenterballDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCenterballDragger", 0, 0, 0)) SWIG_fail;
  result = (SoCenterballDragger *)new SoCenterballDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCenterballDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_saveStartParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_saveStartParameters" "', argument " "1"" of type '" "SoCenterballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  (arg1)->saveStartParameters();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_rotation_set" "', argument " "1"" of type '" "SoCenterballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCenterballDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_rotation_get" "', argument " "1"" of type '" "SoCenterballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballDragger_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_center_set" "', argument " "1"" of type '" "SoCenterballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCenterballDragger_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballDragger_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballDragger_center_get" "', argument " "1"" of type '" "SoCenterballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCenterballDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCenterballDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCenterballDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDirectionalLightDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_getTypeId" "', argument " "1"" of type '" "SoDirectionalLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  result = ((SoDirectionalLightDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoDirectionalLightDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoDirectionalLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoDirectionalLightDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoDirectionalLightDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDirectionalLightDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDirectionalLightDragger", 0, 0, 0)) SWIG_fail;
  result = (SoDirectionalLightDragger *)new SoDirectionalLightDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDirectionalLightDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_rotation_set" "', argument " "1"" of type '" "SoDirectionalLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_rotation_get" "', argument " "1"" of type '" "SoDirectionalLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_translation_set" "', argument " "1"" of type '" "SoDirectionalLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightDragger_translation_get" "', argument " "1"" of type '" "SoDirectionalLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDirectionalLightDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDirectionalLightDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDirectionalLightDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDragPointDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragPointDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDragPointDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_getTypeId" "', argument " "1"" of type '" "SoDragPointDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  result = ((SoDragPointDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragPointDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoDragPointDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoDragPointDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoDragPointDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragPointDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoDragPointDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDragPointDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDragPointDragger", 0, 0, 0)) SWIG_fail;
  result = (SoDragPointDragger *)new SoDragPointDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragPointDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragPointDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_translation_set" "', argument " "1"" of type '" "SoDragPointDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDragPointDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_translation_get" "', argument " "1"" of type '" "SoDragPointDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_setJumpLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDragPointDragger_setJumpLimit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_setJumpLimit" "', argument " "1"" of type '" "SoDragPointDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDragPointDragger_setJumpLimit" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setJumpLimit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_getJumpLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_getJumpLimit" "', argument " "1"" of type '" "SoDragPointDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  result = (float)((SoDragPointDragger const *)arg1)->getJumpLimit();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDragPointDragger_showNextDraggerSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDragPointDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDragPointDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDragPointDragger_showNextDraggerSet" "', argument " "1"" of type '" "SoDragPointDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoDragPointDragger * >(argp1);
  (arg1)->showNextDraggerSet();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDragPointDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDragPointDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDragPointDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoHandleBoxDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_getTypeId" "', argument " "1"" of type '" "SoHandleBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  result = ((SoHandleBoxDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoHandleBoxDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoHandleBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoHandleBoxDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoHandleBoxDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoHandleBoxDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoHandleBoxDragger", 0, 0, 0)) SWIG_fail;
  result = (SoHandleBoxDragger *)new SoHandleBoxDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleBoxDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_scaleFactor_set" "', argument " "1"" of type '" "SoHandleBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleBoxDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_scaleFactor_get" "', argument " "1"" of type '" "SoHandleBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_translation_set" "', argument " "1"" of type '" "SoHandleBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHandleBoxDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxDragger_translation_get" "', argument " "1"" of type '" "SoHandleBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoHandleBoxDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoHandleBoxDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoHandleBoxDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoJackDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoJackDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_getTypeId" "', argument " "1"" of type '" "SoJackDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  result = ((SoJackDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoJackDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoJackDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoJackDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoJackDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoJackDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoJackDragger", 0, 0, 0)) SWIG_fail;
  result = (SoJackDragger *)new SoJackDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoJackDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_rotation_set" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoJackDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_rotation_get" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_translation_set" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoJackDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_translation_get" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_scaleFactor_set" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoJackDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackDragger_scaleFactor_get" "', argument " "1"" of type '" "SoJackDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoJackDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoJackDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoJackDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoJackDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPointLightDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointLightDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightDragger_getTypeId" "', argument " "1"" of type '" "SoPointLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightDragger * >(argp1);
  result = ((SoPointLightDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoPointLightDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoPointLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoPointLightDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoPointLightDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPointLightDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPointLightDragger", 0, 0, 0)) SWIG_fail;
  result = (SoPointLightDragger *)new SoPointLightDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointLightDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightDragger_translation_set" "', argument " "1"" of type '" "SoPointLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightDragger_translation_get" "', argument " "1"" of type '" "SoPointLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointLightDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointLightDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPointLightDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateCylindricalDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotateCylindricalDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_getTypeId" "', argument " "1"" of type '" "SoRotateCylindricalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  result = ((SoRotateCylindricalDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateCylindricalDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoRotateCylindricalDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoRotateCylindricalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoRotateCylindricalDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateCylindricalDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoRotateCylindricalDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotateCylindricalDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotateCylindricalDragger", 0, 0, 0)) SWIG_fail;
  result = (SoRotateCylindricalDragger *)new SoRotateCylindricalDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotateCylindricalDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateCylindricalDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_rotation_set" "', argument " "1"" of type '" "SoRotateCylindricalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotateCylindricalDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_rotation_get" "', argument " "1"" of type '" "SoRotateCylindricalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_setProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  SbCylinderProjector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateCylindricalDragger_setProjector", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_setProjector" "', argument " "1"" of type '" "SoRotateCylindricalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotateCylindricalDragger_setProjector" "', argument " "2"" of type '" "SbCylinderProjector *""'"); 
  }
  arg2 = reinterpret_cast< SbCylinderProjector * >(argp2);
  (arg1)->setProjector(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateCylindricalDragger_getProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateCylindricalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbCylinderProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateCylindricalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateCylindricalDragger_getProjector" "', argument " "1"" of type '" "SoRotateCylindricalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateCylindricalDragger * >(argp1);
  result = (SbCylinderProjector *)((SoRotateCylindricalDragger const *)arg1)->getProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotateCylindricalDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotateCylindricalDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotateCylindricalDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateDiscDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotateDiscDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateDiscDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateDiscDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateDiscDragger_getTypeId" "', argument " "1"" of type '" "SoRotateDiscDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateDiscDragger * >(argp1);
  result = ((SoRotateDiscDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateDiscDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoRotateDiscDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateDiscDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateDiscDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateDiscDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoRotateDiscDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateDiscDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoRotateDiscDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateDiscDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoRotateDiscDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotateDiscDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateDiscDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotateDiscDragger", 0, 0, 0)) SWIG_fail;
  result = (SoRotateDiscDragger *)new SoRotateDiscDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotateDiscDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateDiscDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateDiscDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateDiscDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateDiscDragger_rotation_set" "', argument " "1"" of type '" "SoRotateDiscDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateDiscDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotateDiscDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateDiscDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateDiscDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateDiscDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateDiscDragger_rotation_get" "', argument " "1"" of type '" "SoRotateDiscDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateDiscDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotateDiscDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotateDiscDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotateDiscDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateSphericalDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotateSphericalDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_getTypeId" "', argument " "1"" of type '" "SoRotateSphericalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  result = ((SoRotateSphericalDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateSphericalDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoRotateSphericalDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoRotateSphericalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoRotateSphericalDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateSphericalDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoRotateSphericalDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotateSphericalDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotateSphericalDragger", 0, 0, 0)) SWIG_fail;
  result = (SoRotateSphericalDragger *)new SoRotateSphericalDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotateSphericalDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateSphericalDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_rotation_set" "', argument " "1"" of type '" "SoRotateSphericalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotateSphericalDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_rotation_get" "', argument " "1"" of type '" "SoRotateSphericalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_setProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  SbSphereProjector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotateSphericalDragger_setProjector", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_setProjector" "', argument " "1"" of type '" "SoRotateSphericalDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotateSphericalDragger_setProjector" "', argument " "2"" of type '" "SbSphereProjector *""'"); 
  }
  arg2 = reinterpret_cast< SbSphereProjector * >(argp2);
  (arg1)->setProjector(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotateSphericalDragger_getProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotateSphericalDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbSphereProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotateSphericalDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotateSphericalDragger_getProjector" "', argument " "1"" of type '" "SoRotateSphericalDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotateSphericalDragger * >(argp1);
  result = (SbSphereProjector *)((SoRotateSphericalDragger const *)arg1)->getProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotateSphericalDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotateSphericalDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotateSphericalDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScale1Dragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale1Dragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScale1Dragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale1Dragger_getTypeId" "', argument " "1"" of type '" "SoScale1Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale1Dragger * >(argp1);
  result = ((SoScale1Dragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale1Dragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoScale1Dragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale1Dragger_getNodekitCatalog" "', argument " "1"" of type '" "SoScale1Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale1Dragger * >(argp1);
  result = (SoNodekitCatalog *)((SoScale1Dragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale1Dragger_initClass", 0, 0, 0)) SWIG_fail;
  SoScale1Dragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScale1Dragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale1Dragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScale1Dragger", 0, 0, 0)) SWIG_fail;
  result = (SoScale1Dragger *)new SoScale1Dragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScale1Dragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale1Dragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale1Dragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale1Dragger_scaleFactor_set" "', argument " "1"" of type '" "SoScale1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale1Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale1Dragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale1Dragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale1Dragger_scaleFactor_get" "', argument " "1"" of type '" "SoScale1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale1Dragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScale1Dragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScale1Dragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScale1Dragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScale2Dragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2Dragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScale2Dragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2Dragger_getTypeId" "', argument " "1"" of type '" "SoScale2Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2Dragger * >(argp1);
  result = ((SoScale2Dragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2Dragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoScale2Dragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2Dragger_getNodekitCatalog" "', argument " "1"" of type '" "SoScale2Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2Dragger * >(argp1);
  result = (SoNodekitCatalog *)((SoScale2Dragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2Dragger_initClass", 0, 0, 0)) SWIG_fail;
  SoScale2Dragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScale2Dragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2Dragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScale2Dragger", 0, 0, 0)) SWIG_fail;
  result = (SoScale2Dragger *)new SoScale2Dragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScale2Dragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2Dragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2Dragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2Dragger_scaleFactor_set" "', argument " "1"" of type '" "SoScale2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale2Dragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2Dragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2Dragger_scaleFactor_get" "', argument " "1"" of type '" "SoScale2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2Dragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScale2Dragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScale2Dragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScale2Dragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2UniformDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScale2UniformDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2UniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2UniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2UniformDragger_getTypeId" "', argument " "1"" of type '" "SoScale2UniformDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2UniformDragger * >(argp1);
  result = ((SoScale2UniformDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2UniformDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoScale2UniformDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2UniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2UniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2UniformDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoScale2UniformDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2UniformDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoScale2UniformDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2UniformDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoScale2UniformDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScale2UniformDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2UniformDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScale2UniformDragger", 0, 0, 0)) SWIG_fail;
  result = (SoScale2UniformDragger *)new SoScale2UniformDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScale2UniformDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2UniformDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScale2UniformDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2UniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2UniformDragger_scaleFactor_set" "', argument " "1"" of type '" "SoScale2UniformDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2UniformDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScale2UniformDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScale2UniformDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScale2UniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScale2UniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScale2UniformDragger_scaleFactor_get" "', argument " "1"" of type '" "SoScale2UniformDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScale2UniformDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScale2UniformDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScale2UniformDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScale2UniformDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScaleUniformDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScaleUniformDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScaleUniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScaleUniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScaleUniformDragger_getTypeId" "', argument " "1"" of type '" "SoScaleUniformDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScaleUniformDragger * >(argp1);
  result = ((SoScaleUniformDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScaleUniformDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoScaleUniformDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScaleUniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScaleUniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScaleUniformDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoScaleUniformDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoScaleUniformDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoScaleUniformDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScaleUniformDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoScaleUniformDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScaleUniformDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScaleUniformDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScaleUniformDragger", 0, 0, 0)) SWIG_fail;
  result = (SoScaleUniformDragger *)new SoScaleUniformDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScaleUniformDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScaleUniformDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScaleUniformDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScaleUniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScaleUniformDragger_scaleFactor_set" "', argument " "1"" of type '" "SoScaleUniformDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScaleUniformDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScaleUniformDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScaleUniformDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScaleUniformDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScaleUniformDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScaleUniformDragger_scaleFactor_get" "', argument " "1"" of type '" "SoScaleUniformDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoScaleUniformDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScaleUniformDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScaleUniformDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScaleUniformDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSpotLightDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSpotLightDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_getTypeId" "', argument " "1"" of type '" "SoSpotLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  result = ((SoSpotLightDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoSpotLightDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoSpotLightDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoSpotLightDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoSpotLightDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSpotLightDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSpotLightDragger", 0, 0, 0)) SWIG_fail;
  result = (SoSpotLightDragger *)new SoSpotLightDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSpotLightDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_rotation_set" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_rotation_get" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_translation_set" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_translation_get" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightDragger_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_angle_set" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightDragger_angle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->angle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightDragger_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightDragger_angle_get" "', argument " "1"" of type '" "SoSpotLightDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightDragger * >(argp1);
  result = (SoSFFloat *)& ((arg1)->angle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSpotLightDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSpotLightDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSpotLightDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTabBoxDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTabBoxDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_getTypeId" "', argument " "1"" of type '" "SoTabBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  result = ((SoTabBoxDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTabBoxDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTabBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTabBoxDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTabBoxDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTabBoxDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTabBoxDragger", 0, 0, 0)) SWIG_fail;
  result = (SoTabBoxDragger *)new SoTabBoxDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTabBoxDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_translation_set" "', argument " "1"" of type '" "SoTabBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTabBoxDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_translation_get" "', argument " "1"" of type '" "SoTabBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_scaleFactor_set" "', argument " "1"" of type '" "SoTabBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTabBoxDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_scaleFactor_get" "', argument " "1"" of type '" "SoTabBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxDragger_adjustScaleTabSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxDragger_adjustScaleTabSize" "', argument " "1"" of type '" "SoTabBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxDragger * >(argp1);
  (arg1)->adjustScaleTabSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTabBoxDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTabBoxDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTabBoxDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabPlaneDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTabPlaneDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_getTypeId" "', argument " "1"" of type '" "SoTabPlaneDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  result = ((SoTabPlaneDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabPlaneDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTabPlaneDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTabPlaneDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTabPlaneDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabPlaneDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTabPlaneDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTabPlaneDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTabPlaneDragger", 0, 0, 0)) SWIG_fail;
  result = (SoTabPlaneDragger *)new SoTabPlaneDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTabPlaneDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabPlaneDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_translation_set" "', argument " "1"" of type '" "SoTabPlaneDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTabPlaneDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_translation_get" "', argument " "1"" of type '" "SoTabPlaneDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabPlaneDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_scaleFactor_set" "', argument " "1"" of type '" "SoTabPlaneDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTabPlaneDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_scaleFactor_get" "', argument " "1"" of type '" "SoTabPlaneDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabPlaneDragger_adjustScaleTabSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabPlaneDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabPlaneDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabPlaneDragger_adjustScaleTabSize" "', argument " "1"" of type '" "SoTabPlaneDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTabPlaneDragger * >(argp1);
  (arg1)->adjustScaleTabSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTabPlaneDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTabPlaneDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTabPlaneDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTrackballDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTrackballDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_getTypeId" "', argument " "1"" of type '" "SoTrackballDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  result = ((SoTrackballDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTrackballDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTrackballDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTrackballDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTrackballDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTrackballDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTrackballDragger", 0, 0, 0)) SWIG_fail;
  result = (SoTrackballDragger *)new SoTrackballDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTrackballDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_rotation_set" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTrackballDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_rotation_get" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_scaleFactor_set" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTrackballDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_scaleFactor_get" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_isAnimationEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_isAnimationEnabled" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  result = (SbBool)(arg1)->isAnimationEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballDragger_setAnimationEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballDragger *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballDragger_setAnimationEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballDragger_setAnimationEnabled" "', argument " "1"" of type '" "SoTrackballDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballDragger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTrackballDragger_setAnimationEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAnimationEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTrackballDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTrackballDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTrackballDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformBoxDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_getTypeId" "', argument " "1"" of type '" "SoTransformBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  result = ((SoTransformBoxDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTransformBoxDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTransformBoxDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTransformBoxDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformBoxDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformBoxDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformBoxDragger", 0, 0, 0)) SWIG_fail;
  result = (SoTransformBoxDragger *)new SoTransformBoxDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformBoxDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_rotation_set" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformBoxDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_rotation_get" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_translation_set" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformBoxDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_translation_get" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_scaleFactor_set" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformBoxDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxDragger_scaleFactor_get" "', argument " "1"" of type '" "SoTransformBoxDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformBoxDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformBoxDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformBoxDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformerDragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformerDragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getTypeId" "', argument " "1"" of type '" "SoTransformerDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = ((SoTransformerDragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTransformerDragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTransformerDragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTransformerDragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformerDragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformerDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformerDragger", 0, 0, 0)) SWIG_fail;
  result = (SoTransformerDragger *)new SoTransformerDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformerDragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_rotation_set" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_rotation_get" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_translation_set" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_translation_get" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_scaleFactor_set" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_scaleFactor_get" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_minDiscRotDot_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_minDiscRotDot_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_minDiscRotDot_set" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_minDiscRotDot_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->minDiscRotDot = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_minDiscRotDot_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_minDiscRotDot_get" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoSFFloat *)& ((arg1)->minDiscRotDot);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getCurrentState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTransformerDragger::State result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getCurrentState" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SoTransformerDragger::State)(arg1)->getCurrentState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_unsquishKnobs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_unsquishKnobs" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  (arg1)->unsquishKnobs();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_isLocateHighlighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_isLocateHighlighting" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (SbBool)(arg1)->isLocateHighlighting();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_setLocateHighlighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_setLocateHighlighting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_setLocateHighlighting" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTransformerDragger_setLocateHighlighting" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setLocateHighlighting(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_setColinearThreshold(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoTransformerDragger_setColinearThreshold" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SoTransformerDragger::setColinearThreshold(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getColinearThreshold(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getColinearThreshold", 0, 0, 0)) SWIG_fail;
  result = (int)SoTransformerDragger::getColinearThreshold();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getBoxPointInWorldSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getBoxPointInWorldSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getBoxPointInWorldSpace" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_getBoxPointInWorldSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransformerDragger_getBoxPointInWorldSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (arg1)->getBoxPointInWorldSpace((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getBoxDirInWorldSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getBoxDirInWorldSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getBoxDirInWorldSpace" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_getBoxDirInWorldSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransformerDragger_getBoxDirInWorldSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (arg1)->getBoxDirInWorldSpace((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getWorldPointInBoxSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getWorldPointInBoxSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getWorldPointInBoxSpace" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_getWorldPointInBoxSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransformerDragger_getWorldPointInBoxSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (arg1)->getWorldPointInBoxSpace((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getWorldPointInPixelSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerDragger_getWorldPointInPixelSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getWorldPointInPixelSpace" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformerDragger_getWorldPointInPixelSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransformerDragger_getWorldPointInPixelSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (arg1)->getWorldPointInPixelSpace((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerDragger_getInteractiveCenterInBoxSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerDragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerDragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerDragger_getInteractiveCenterInBoxSpace" "', argument " "1"" of type '" "SoTransformerDragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerDragger * >(argp1);
  result = (arg1)->getInteractiveCenterInBoxSpace();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformerDragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformerDragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformerDragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTranslate1Dragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_getTypeId" "', argument " "1"" of type '" "SoTranslate1Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  result = ((SoTranslate1Dragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTranslate1Dragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTranslate1Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTranslate1Dragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTranslate1Dragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTranslate1Dragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTranslate1Dragger", 0, 0, 0)) SWIG_fail;
  result = (SoTranslate1Dragger *)new SoTranslate1Dragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTranslate1Dragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_translation_set" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate1Dragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_translation_get" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_minTranslation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_minTranslation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_minTranslation_set" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate1Dragger_minTranslation_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->minTranslation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_minTranslation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_minTranslation_get" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  result = (SoSFFloat *)& ((arg1)->minTranslation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_maxTranslation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate1Dragger_maxTranslation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_maxTranslation_set" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate1Dragger_maxTranslation_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->maxTranslation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate1Dragger_maxTranslation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate1Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate1Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate1Dragger_maxTranslation_get" "', argument " "1"" of type '" "SoTranslate1Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate1Dragger * >(argp1);
  result = (SoSFFloat *)& ((arg1)->maxTranslation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTranslate1Dragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTranslate1Dragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTranslate1Dragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec2f", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec2f *)new SoSFVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec2f" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_getTypeId" "', argument " "1"" of type '" "SoSFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  result = ((SoSFVec2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_copyFrom" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_isSame" "', argument " "1"" of type '" "SoSFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec2f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_getValue" "', argument " "1"" of type '" "SoSFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  result = (SbVec2f *) &((SoSFVec2f const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_setValue" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f___eq__" "', argument " "1"" of type '" "SoSFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f___eq__" "', argument " "2"" of type '" "SoSFVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2f___eq__" "', argument " "2"" of type '" "SoSFVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  result = (int)((SoSFVec2f const *)arg1)->operator ==((SoSFVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f___ne__" "', argument " "1"" of type '" "SoSFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f___ne__" "', argument " "2"" of type '" "SoSFVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2f___ne__" "', argument " "2"" of type '" "SoSFVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  result = (int)((SoSFVec2f const *)arg1)->operator !=((SoSFVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2f_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_setValue" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec2f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec2f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[2] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_setValue" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  {
    convert_SbVec2f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2f *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2f_setValue" "', argument " "1"" of type '" "SoSFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2f_setValue" "', argument " "2"" of type '" "SoSFVec2f const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  SoSFVec2f_setValue__SWIG_3(arg1,(SoSFVec2f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec2f_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFVec2f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFVec2f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFVec2f_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec2f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec2f::setValue(SbVec2f const &)\n"
    "    SoSFVec2f::setValue(float,float)\n"
    "    SoSFVec2f::setValue(float const [2])\n"
    "    SoSFVec2f::setValue(SoSFVec2f const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTranslate2Dragger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_getTypeId" "', argument " "1"" of type '" "SoTranslate2Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  result = ((SoTranslate2Dragger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoTranslate2Dragger::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_getNodekitCatalog" "', argument " "1"" of type '" "SoTranslate2Dragger const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  result = (SoNodekitCatalog *)((SoTranslate2Dragger const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_initClass", 0, 0, 0)) SWIG_fail;
  SoTranslate2Dragger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTranslate2Dragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTranslate2Dragger", 0, 0, 0)) SWIG_fail;
  result = (SoTranslate2Dragger *)new SoTranslate2Dragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTranslate2Dragger, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_translation_set" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate2Dragger_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_translation_get" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_minTranslation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_minTranslation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_minTranslation_set" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate2Dragger_minTranslation_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->minTranslation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_minTranslation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_minTranslation_get" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->minTranslation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_maxTranslation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslate2Dragger_maxTranslation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_maxTranslation_set" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslate2Dragger_maxTranslation_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->maxTranslation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslate2Dragger_maxTranslation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslate2Dragger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslate2Dragger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslate2Dragger_maxTranslation_get" "', argument " "1"" of type '" "SoTranslate2Dragger *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslate2Dragger * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->maxTranslation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTranslate2Dragger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTranslate2Dragger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTranslate2Dragger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAccumulatedElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAccumulatedElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAccumulatedElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAccumulatedElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAccumulatedElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoAccumulatedElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAccumulatedElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAccumulatedElement_initClass", 0, 0, 0)) SWIG_fail;
  SoAccumulatedElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAccumulatedElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAccumulatedElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAccumulatedElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAccumulatedElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAccumulatedElement_matches" "', argument " "1"" of type '" "SoAccumulatedElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoAccumulatedElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAccumulatedElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoAccumulatedElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAccumulatedElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAccumulatedElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoAmbientColorElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAmbientColorElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoAmbientColorElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoAmbientColorElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_initClass", 0, 0, 0)) SWIG_fail;
  SoAmbientColorElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAmbientColorElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAmbientColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_init" "', argument " "1"" of type '" "SoAmbientColorElement *""'"); 
  }
  arg1 = reinterpret_cast< SoAmbientColorElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAmbientColorElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbColor *arg4 = (SbColor *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAmbientColorElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAmbientColorElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoAmbientColorElement_set" "', argument " "4"" of type '" "SbColor const *const""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  SoAmbientColorElement::set(arg1,arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAmbientColorElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoAmbientColorElement *)SoAmbientColorElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAmbientColorElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAmbientColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAmbientColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_getNum" "', argument " "1"" of type '" "SoAmbientColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoAmbientColorElement * >(argp1);
  result = (int32_t)((SoAmbientColorElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAmbientColorElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAmbientColorElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAmbientColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_get" "', argument " "1"" of type '" "SoAmbientColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoAmbientColorElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAmbientColorElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &((SoAmbientColorElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAmbientColorElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAmbientColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAmbientColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAmbientColorElement_getArrayPtr" "', argument " "1"" of type '" "SoAmbientColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoAmbientColorElement * >(argp1);
  result = (SbColor *)((SoAmbientColorElement const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAmbientColorElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAmbientColorElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAnnoText3CharOrientElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoAnnoText3CharOrientElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoAnnoText3CharOrientElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_initClass", 0, 0, 0)) SWIG_fail;
  SoAnnoText3CharOrientElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnoText3CharOrientElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnoText3CharOrientElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3CharOrientElement_init" "', argument " "1"" of type '" "SoAnnoText3CharOrientElement *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnoText3CharOrientElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnoText3CharOrientElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3CharOrientElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAnnoText3CharOrientElement_set" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoAnnoText3CharOrientElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3CharOrientElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoAnnoText3CharOrientElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3CharOrientElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3CharOrientElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoAnnoText3CharOrientElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAnnoText3CharOrientElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAnnoText3CharOrientElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAnnoText3FontSizeHintElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoAnnoText3FontSizeHintElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoAnnoText3FontSizeHintElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_initClass", 0, 0, 0)) SWIG_fail;
  SoAnnoText3FontSizeHintElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnoText3FontSizeHintElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnoText3FontSizeHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3FontSizeHintElement_init" "', argument " "1"" of type '" "SoAnnoText3FontSizeHintElement *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnoText3FontSizeHintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnoText3FontSizeHintElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoAnnoText3FontSizeHintElement::FontSizeHint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3FontSizeHintElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAnnoText3FontSizeHintElement_set" "', argument " "2"" of type '" "SoAnnoText3FontSizeHintElement::FontSizeHint""'");
  } 
  arg2 = static_cast< SoAnnoText3FontSizeHintElement::FontSizeHint >(val2);
  SoAnnoText3FontSizeHintElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAnnoText3FontSizeHintElement::FontSizeHint result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3FontSizeHintElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoAnnoText3FontSizeHintElement::FontSizeHint)SoAnnoText3FontSizeHintElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnoText3FontSizeHintElement::FontSizeHint result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoAnnoText3FontSizeHintElement::FontSizeHint)SoAnnoText3FontSizeHintElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoAnnoText3FontSizeHintElement::FontSizeHint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3FontSizeHintElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnoText3FontSizeHintElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAnnoText3FontSizeHintElement_set" "', argument " "3"" of type '" "SoAnnoText3FontSizeHintElement::FontSizeHint""'");
  } 
  arg3 = static_cast< SoAnnoText3FontSizeHintElement::FontSizeHint >(val3);
  SoAnnoText3FontSizeHintElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3FontSizeHintElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAnnoText3FontSizeHintElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAnnoText3FontSizeHintElement_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoAnnoText3FontSizeHintElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAnnoText3FontSizeHintElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAnnoText3FontSizeHintElement::set(SoState *const,SoAnnoText3FontSizeHintElement::FontSizeHint const)\n"
    "    SoAnnoText3FontSizeHintElement::set(SoState *const,SoNode *const,SoAnnoText3FontSizeHintElement::FontSizeHint const)\n");
  return 0;
}


SWIGINTERN PyObject *SoAnnoText3FontSizeHintElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAnnoText3FontSizeHintElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAnnoText3RenderPrintElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoAnnoText3RenderPrintElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoAnnoText3RenderPrintElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_initClass", 0, 0, 0)) SWIG_fail;
  SoAnnoText3RenderPrintElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnoText3RenderPrintElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnoText3RenderPrintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3RenderPrintElement_init" "', argument " "1"" of type '" "SoAnnoText3RenderPrintElement *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnoText3RenderPrintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnoText3RenderPrintElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoAnnoText3RenderPrintElement::RenderPrintType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3RenderPrintElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAnnoText3RenderPrintElement_set" "', argument " "2"" of type '" "SoAnnoText3RenderPrintElement::RenderPrintType""'");
  } 
  arg2 = static_cast< SoAnnoText3RenderPrintElement::RenderPrintType >(val2);
  SoAnnoText3RenderPrintElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAnnoText3RenderPrintElement::RenderPrintType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3RenderPrintElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoAnnoText3RenderPrintElement::RenderPrintType)SoAnnoText3RenderPrintElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnoText3RenderPrintElement::RenderPrintType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoAnnoText3RenderPrintElement::RenderPrintType)SoAnnoText3RenderPrintElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoAnnoText3RenderPrintElement::RenderPrintType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnoText3RenderPrintElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnoText3RenderPrintElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoAnnoText3RenderPrintElement_set" "', argument " "3"" of type '" "SoAnnoText3RenderPrintElement::RenderPrintType""'");
  } 
  arg3 = static_cast< SoAnnoText3RenderPrintElement::RenderPrintType >(val3);
  SoAnnoText3RenderPrintElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnoText3RenderPrintElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAnnoText3RenderPrintElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAnnoText3RenderPrintElement_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoAnnoText3RenderPrintElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAnnoText3RenderPrintElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAnnoText3RenderPrintElement::set(SoState *const,SoAnnoText3RenderPrintElement::RenderPrintType const)\n"
    "    SoAnnoText3RenderPrintElement::set(SoState *const,SoNode *const,SoAnnoText3RenderPrintElement::RenderPrintType const)\n");
  return 0;
}


SWIGINTERN PyObject *SoAnnoText3RenderPrintElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAnnoText3RenderPrintElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoModelMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoModelMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoModelMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoModelMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoModelMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_init" "', argument " "1"" of type '" "SoModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_push" "', argument " "1"" of type '" "SoModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoModelMatrixElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_matches" "', argument " "1"" of type '" "SoModelMatrixElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoModelMatrixElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_makeIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_makeIdentity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_makeIdentity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_makeIdentity" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoModelMatrixElement::makeIdentity(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoModelMatrixElement::set(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_setCullMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_setCullMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_setCullMatrix" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_setCullMatrix" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoModelMatrixElement::setCullMatrix(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_mult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_mult", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_mult" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_mult" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoModelMatrixElement::mult(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_translateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_translateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_translateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_translateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoModelMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoModelMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoModelMatrixElement::translateBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_rotateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_rotateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_rotateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_rotateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoModelMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoModelMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  SoModelMatrixElement::rotateBy(arg1,arg2,(SbRotation const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_scaleBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_scaleBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_scaleBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_scaleBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoModelMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoModelMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoModelMatrixElement::scaleBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_pushMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_pushMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = SoModelMatrixElement::pushMatrix(arg1);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_popMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_popMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoModelMatrixElement::popMatrix(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_getCombinedCullMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_getCombinedCullMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoModelMatrixElement::getCombinedCullMatrix(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoModelMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoModelMatrixElement_get" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoModelMatrixElement_get" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  result = (SbMatrix *) &SoModelMatrixElement::get(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoModelMatrixElement_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoModelMatrixElement_get__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoModelMatrixElement_get__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoModelMatrixElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoModelMatrixElement::get(SoState *const)\n"
    "    SoModelMatrixElement::get(SoState *const,SbBool &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoModelMatrixElement_getModelMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoModelMatrixElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoModelMatrixElement_getModelMatrix" "', argument " "1"" of type '" "SoModelMatrixElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoModelMatrixElement * >(argp1);
  result = (SbMatrix *) &((SoModelMatrixElement const *)arg1)->getModelMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoModelMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoModelMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBBoxModelMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoBBoxModelMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoBBoxModelMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoBBoxModelMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBBoxModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBBoxModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBBoxModelMatrixElement_init" "', argument " "1"" of type '" "SoBBoxModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBBoxModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBBoxModelMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBBoxModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBBoxModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBBoxModelMatrixElement_push" "', argument " "1"" of type '" "SoBBoxModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBBoxModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBBoxModelMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_reset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBBoxModelMatrixElement_reset" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBBoxModelMatrixElement_reset" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoBBoxModelMatrixElement::reset(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_pushMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_pushMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBBoxModelMatrixElement_pushMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBBoxModelMatrixElement_pushMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBBoxModelMatrixElement_pushMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  SoBBoxModelMatrixElement::pushMatrix(arg1,*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBBoxModelMatrixElement_popMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBBoxModelMatrixElement_popMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBBoxModelMatrixElement_popMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBBoxModelMatrixElement_popMatrix" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBBoxModelMatrixElement_popMatrix" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  SoBBoxModelMatrixElement::popMatrix(arg1,(SbMatrix const &)*arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBBoxModelMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBBoxModelMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMapCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoBumpMapCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoBumpMapCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMapCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_init" "', argument " "1"" of type '" "SoBumpMapCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinateElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int32_t arg3 ;
  SbVec2f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinateElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoBumpMapCoordinateElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoBumpMapCoordinateElement_set" "', argument " "4"" of type '" "SbVec2f const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  SoBumpMapCoordinateElement::set(arg1,arg2,arg3,(SbVec2f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoBumpMapCoordinateElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoBumpMapCoordinateElement *)SoBumpMapCoordinateElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBumpMapCoordinateElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_getNum" "', argument " "1"" of type '" "SoBumpMapCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinateElement * >(argp1);
  result = (int32_t)((SoBumpMapCoordinateElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinateElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_get" "', argument " "1"" of type '" "SoBumpMapCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoBumpMapCoordinateElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &((SoBumpMapCoordinateElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinateElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinateElement_getArrayPtr" "', argument " "1"" of type '" "SoBumpMapCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinateElement * >(argp1);
  result = (SbVec2f *)((SoBumpMapCoordinateElement const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMapCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMapCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoBumpMapElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMapElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoBumpMapElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoBumpMapElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMapElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapElement_init" "', argument " "1"" of type '" "SoBumpMapElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoGLImage *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBumpMapElement_set" "', argument " "3"" of type '" "SoGLImage *""'"); 
  }
  arg3 = reinterpret_cast< SoGLImage * >(argp3);
  SoBumpMapElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLImage *)SoBumpMapElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMapElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMapElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMapMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoBumpMapMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoBumpMapMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMapMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_init" "', argument " "1"" of type '" "SoBumpMapMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_push" "', argument " "1"" of type '" "SoBumpMapMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_makeIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_makeIdentity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_makeIdentity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_makeIdentity" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoBumpMapMatrixElement::makeIdentity(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoBumpMapMatrixElement::set(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_mult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_mult", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_mult" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_mult" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoBumpMapMatrixElement::mult(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_translateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_translateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_translateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_translateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBumpMapMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBumpMapMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoBumpMapMatrixElement::translateBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_rotateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_rotateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_rotateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_rotateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBumpMapMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBumpMapMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  SoBumpMapMatrixElement::rotateBy(arg1,arg2,(SbRotation const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_scaleBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapMatrixElement_scaleBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_scaleBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapMatrixElement_scaleBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoBumpMapMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoBumpMapMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoBumpMapMatrixElement::scaleBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapMatrixElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoBumpMapMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMapMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMapMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoCacheElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCacheElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoCacheElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCacheElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_initClass", 0, 0, 0)) SWIG_fail;
  SoCacheElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_init" "', argument " "1"" of type '" "SoCacheElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_push" "', argument " "1"" of type '" "SoCacheElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_pop" "', argument " "1"" of type '" "SoCacheElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCacheElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoCache *arg2 = (SoCache *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_set" "', argument " "2"" of type '" "SoCache *const""'"); 
  }
  arg2 = reinterpret_cast< SoCache * >(argp2);
  SoCacheElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_getCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_getCache" "', argument " "1"" of type '" "SoCacheElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  result = (SoCache *)((SoCacheElement const *)arg1)->getCache();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCache, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_anyOpen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_anyOpen" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoCacheElement::anyOpen(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_invalidate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_invalidate" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoCacheElement::invalidate(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_matches" "', argument " "1"" of type '" "SoCacheElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoCacheElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_copyMatchInfo" "', argument " "1"" of type '" "SoCacheElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  result = (SoElement *)((SoCacheElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_getNextCacheElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCacheElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_getNextCacheElement" "', argument " "1"" of type '" "SoCacheElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheElement * >(argp1);
  result = (SoCacheElement *)((SoCacheElement const *)arg1)->getNextCacheElement();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCacheElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_addElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoElement *arg2 = (SoElement *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_addElement", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_addElement" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_addElement" "', argument " "2"" of type '" "SoElement const *const""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  SoCacheElement::addElement(arg1,(SoElement const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_addCacheDependency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoCache *arg2 = (SoCache *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheElement_addCacheDependency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_addCacheDependency" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCache, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheElement_addCacheDependency" "', argument " "2"" of type '" "SoCache *const""'"); 
  }
  arg2 = reinterpret_cast< SoCache * >(argp2);
  SoCacheElement::addCacheDependency(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_setInvalid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoCacheElement_setInvalid" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SbBool)SoCacheElement::setInvalid(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheElement_getCurrentCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCache *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheElement_getCurrentCache" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoCache *)SoCacheElement::getCurrentCache(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCache, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCacheElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCacheElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbPlane__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbPlane *)new SbPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlane__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbPlane" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbPlane *)new SbPlane((SbVec3f const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlane__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbPlane" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SbPlane" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbPlane *)new SbPlane((SbVec3f const &)*arg1,(SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlane__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbPlane" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlane" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbPlane *)new SbPlane((SbVec3f const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlane(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbPlane", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbPlane__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbPlane__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbPlane__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SbPlane__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbPlane'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPlane::SbPlane()\n"
    "    SbPlane::SbPlane(SbVec3f const &,float const)\n"
    "    SbPlane::SbPlane(SbVec3f const &,SbVec3f const &,SbVec3f const &)\n"
    "    SbPlane::SbPlane(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbPlane_offset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane_offset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_offset" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPlane_offset" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->offset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_transform" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  (arg1)->transform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_isInHalfSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane_isInHalfSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_isInHalfSpace" "', argument " "1"" of type '" "SbPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane_isInHalfSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane_isInHalfSpace" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbPlane const *)arg1)->isInHalfSpace((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_getDistance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane_getDistance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_getDistance" "', argument " "1"" of type '" "SbPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane_getDistance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane_getDistance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (float)((SbPlane const *)arg1)->getDistance((SbVec3f const &)*arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_getNormal" "', argument " "1"" of type '" "SbPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  result = (SbVec3f *) &((SbPlane const *)arg1)->getNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_getDistanceFromOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_getDistanceFromOrigin" "', argument " "1"" of type '" "SbPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  result = (float)((SbPlane const *)arg1)->getDistanceFromOrigin();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_output" "', argument " "1"" of type '" "SbPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbPlane const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane___eq__" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane___eq__" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane___eq__" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  result = (int)SbPlane___eq__(arg1,(SbPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbPlane___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlane___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane___ne__" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane___ne__" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane___ne__" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  result = (int)SbPlane___ne__(arg1,(SbPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbPlane_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_intersect" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  result = (PyObject *)SbPlane_intersect__SWIG_0(arg1,(SbLine const &)*arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlane_intersect" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlane_intersect" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlane_intersect" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  result = (PyObject *)SbPlane_intersect__SWIG_1(arg1,(SbPlane const &)*arg2);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlane_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbPlane_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbPlane_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbPlane_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbPlane_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPlane::intersect(SbLine const &)\n"
    "    SbPlane::intersect(SbPlane const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlane, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbPlane" "', argument " "1"" of type '" "SbPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbPlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbPlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbPlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoClipPlaneElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoClipPlaneElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoClipPlaneElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoClipPlaneElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_initClass", 0, 0, 0)) SWIG_fail;
  SoClipPlaneElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_init" "', argument " "1"" of type '" "SoClipPlaneElement *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_push" "', argument " "1"" of type '" "SoClipPlaneElement *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_add", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_add" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneElement_add" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoClipPlaneElement_add" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoClipPlaneElement_add" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbPlane * >(argp3);
  SoClipPlaneElement::add(arg1,arg2,(SbPlane const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoClipPlaneElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoClipPlaneElement *)SoClipPlaneElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_getNum" "', argument " "1"" of type '" "SoClipPlaneElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneElement * >(argp1);
  result = (int)((SoClipPlaneElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoClipPlaneElement *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_get" "', argument " "1"" of type '" "SoClipPlaneElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoClipPlaneElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoClipPlaneElement_get" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbPlane *) &((SoClipPlaneElement const *)arg1)->get(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoClipPlaneElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneElement_get" "', argument " "1"" of type '" "SoClipPlaneElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoClipPlaneElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbPlane *) &((SoClipPlaneElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoClipPlaneElement_get", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoClipPlaneElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoClipPlaneElement_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoClipPlaneElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoClipPlaneElement_get__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoClipPlaneElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoClipPlaneElement::get(int const,SbBool const) const\n"
    "    SoClipPlaneElement::get(int const) const\n");
  return 0;
}


SWIGINTERN PyObject *SoClipPlaneElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoClipPlaneElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoFloatElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFloatElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoFloatElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_initClass", 0, 0, 0)) SWIG_fail;
  SoFloatElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFloatElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFloatElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFloatElement_init" "', argument " "1"" of type '" "SoFloatElement *""'"); 
  }
  arg1 = reinterpret_cast< SoFloatElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFloatElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFloatElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFloatElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFloatElement_matches" "', argument " "1"" of type '" "SoFloatElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFloatElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFloatElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoFloatElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFloatElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFloatElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFloatElement_copyMatchInfo" "', argument " "1"" of type '" "SoFloatElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFloatElement * >(argp1);
  result = (SoElement *)((SoFloatElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFloatElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFloatElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFloatElement_output" "', argument " "1"" of type '" "SoFloatElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFloatElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoFloatElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  SoNode *arg3 = (SoNode *)0 ;
  float arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoFloatElement_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFloatElement_set" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFloatElement_set" "', argument " "3"" of type '" "SoNode *const""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoFloatElement_set" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  SoFloatElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  float arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoFloatElement_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFloatElement_set" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFloatElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoFloatElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFloatElement_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoFloatElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoFloatElement_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFloatElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFloatElement::set(int const,SoState *const,SoNode *const,float const)\n"
    "    SoFloatElement::set(int const,SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SoState *arg2 = (SoState *)0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_get", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoFloatElement_get" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFloatElement_get" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (float)SoFloatElement::get(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFloatElement_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFloatElement *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFloatElement_setElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFloatElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFloatElement_setElt" "', argument " "1"" of type '" "SoFloatElement *""'"); 
  }
  arg1 = reinterpret_cast< SoFloatElement * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFloatElement_setElt" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setElt(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFloatElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFloatElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoComplexityElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComplexityElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoComplexityElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComplexityElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_initClass", 0, 0, 0)) SWIG_fail;
  SoComplexityElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComplexityElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComplexityElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityElement_init" "', argument " "1"" of type '" "SoComplexityElement *""'"); 
  }
  arg1 = reinterpret_cast< SoComplexityElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexityElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComplexityElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoComplexityElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoComplexityElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoComplexityElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoComplexityElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoComplexityElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoComplexityElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoComplexityElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoComplexityElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoComplexityElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoComplexityElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComplexityElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoComplexityElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComplexityElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComplexityElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoComplexityElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComplexityElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComplexityElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_init" "', argument " "1"" of type '" "SoCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinateElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_set3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec3f *arg4 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_set3", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_set3" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinateElement_set3" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCoordinateElement_set3" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCoordinateElement_set3" "', argument " "4"" of type '" "SbVec3f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  SoCoordinateElement::set3(arg1,arg2,arg3,(SbVec3f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_set4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec4f *arg4 = (SbVec4f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_set4", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_set4" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinateElement_set4" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCoordinateElement_set4" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCoordinateElement_set4" "', argument " "4"" of type '" "SbVec4f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec4f * >(argp4);
  SoCoordinateElement::set4(arg1,arg2,arg3,(SbVec4f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCoordinateElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoCoordinateElement *)SoCoordinateElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_getNum" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  result = (int32_t)((SoCoordinateElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_is3D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_is3D" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  result = (SbBool)((SoCoordinateElement const *)arg1)->is3D();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_get3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_get3", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_get3" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCoordinateElement_get3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoCoordinateElement const *)arg1)->get3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_get4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_get4", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_get4" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCoordinateElement_get4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &((SoCoordinateElement const *)arg1)->get4(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getArrayPtr3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_getArrayPtr3" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  result = (SbVec3f *)((SoCoordinateElement const *)arg1)->getArrayPtr3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getArrayPtr4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_getArrayPtr4" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  result = (SbVec4f *)((SoCoordinateElement const *)arg1)->getArrayPtr4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getDefault3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_getDefault3", 0, 0, 0)) SWIG_fail;
  result = SoCoordinateElement::getDefault3();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_getDefault4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_getDefault4", 0, 0, 0)) SWIG_fail;
  result = SoCoordinateElement::getDefault4();
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinateElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinateElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinateElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinateElement_output" "', argument " "1"" of type '" "SoCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinateElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoCoordinateElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCreaseAngleElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoCreaseAngleElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCreaseAngleElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_initClass", 0, 0, 0)) SWIG_fail;
  SoCreaseAngleElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCreaseAngleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCreaseAngleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCreaseAngleElement_init" "', argument " "1"" of type '" "SoCreaseAngleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCreaseAngleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCreaseAngleElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCreaseAngleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCreaseAngleElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCreaseAngleElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoCreaseAngleElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCreaseAngleElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCreaseAngleElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoCreaseAngleElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoCreaseAngleElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoCreaseAngleElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCreaseAngleElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCreaseAngleElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoCreaseAngleElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCreaseAngleElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoCreaseAngleElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCreaseAngleElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCreaseAngleElement_get" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (float)SoCreaseAngleElement::get(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoCreaseAngleElement_get__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoCreaseAngleElement_get__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCreaseAngleElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCreaseAngleElement::get(SoState *const)\n"
    "    SoCreaseAngleElement::get(SoState *const,SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_getDefault__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (float)SoCreaseAngleElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_getDefault__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoCreaseAngleElement_getDefault" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (float)SoCreaseAngleElement::getDefault(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCreaseAngleElement_getDefault(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCreaseAngleElement_getDefault", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_SoCreaseAngleElement_getDefault__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_SoCreaseAngleElement_getDefault__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCreaseAngleElement_getDefault'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCreaseAngleElement::getDefault()\n"
    "    SoCreaseAngleElement::getDefault(SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *SoCreaseAngleElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCreaseAngleElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoCullElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCullElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoCullElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCullElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_initClass", 0, 0, 0)) SWIG_fail;
  SoCullElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCullElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCullElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_init" "', argument " "1"" of type '" "SoCullElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCullElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCullElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCullElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_push" "', argument " "1"" of type '" "SoCullElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCullElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_setViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbViewVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_setViewVolume", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_setViewVolume" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewVolume,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewVolume * >(argp2);
  SoCullElement::setViewVolume(arg1,(SbViewVolume const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_addPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_addPlane", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_addPlane" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_addPlane" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_addPlane" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  SoCullElement::addPlane(arg1,(SbPlane const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullBox__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_cullBox" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_cullBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_cullBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCullElement_cullBox" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)SoCullElement::cullBox(arg1,(SbBox3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullBox__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_cullBox" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_cullBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_cullBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)SoCullElement::cullBox(arg1,(SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullBox(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCullElement_cullBox", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCullElement_cullBox__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoCullElement_cullBox__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCullElement_cullBox'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCullElement::cullBox(SoState *,SbBox3f const &,SbBool const)\n"
    "    SoCullElement::cullBox(SoState *,SbBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullTest__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_cullTest" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_cullTest" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_cullTest" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCullElement_cullTest" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)SoCullElement::cullTest(arg1,(SbBox3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullTest__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_cullTest" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_cullTest" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCullElement_cullTest" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBool)SoCullElement::cullTest(arg1,(SbBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_cullTest(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCullElement_cullTest", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCullElement_cullTest__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoCullElement_cullTest__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCullElement_cullTest'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCullElement::cullTest(SoState *,SbBox3f const &,SbBool const)\n"
    "    SoCullElement::cullTest(SoState *,SbBox3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCullElement_completelyInside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_completelyInside" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoCullElement::completelyInside(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCullElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCullElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCullElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_matches" "', argument " "1"" of type '" "SoCullElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCullElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCullElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoCullElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCullElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCullElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCullElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCullElement_copyMatchInfo" "', argument " "1"" of type '" "SoCullElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCullElement * >(argp1);
  result = (SoElement *)((SoCullElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCullElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCullElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecimationPercentageElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoDecimationPercentageElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecimationPercentageElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_initClass", 0, 0, 0)) SWIG_fail;
  SoDecimationPercentageElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecimationPercentageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecimationPercentageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationPercentageElement_init" "', argument " "1"" of type '" "SoDecimationPercentageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDecimationPercentageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecimationPercentageElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationPercentageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecimationPercentageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDecimationPercentageElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoDecimationPercentageElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationPercentageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDecimationPercentageElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoDecimationPercentageElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoDecimationPercentageElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoDecimationPercentageElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoDecimationPercentageElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoDecimationPercentageElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoDecimationPercentageElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecimationPercentageElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoDecimationPercentageElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecimationPercentageElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecimationPercentageElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoDecimationPercentageElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecimationPercentageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecimationPercentageElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDiffuseColorElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoDiffuseColorElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDiffuseColorElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_initClass", 0, 0, 0)) SWIG_fail;
  SoDiffuseColorElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_init" "', argument " "1"" of type '" "SoDiffuseColorElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDiffuseColorElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbColor *arg4 = (SbColor *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDiffuseColorElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDiffuseColorElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDiffuseColorElement_set" "', argument " "4"" of type '" "SbColor const *const""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  SoDiffuseColorElement::set(arg1,arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDiffuseColorElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoDiffuseColorElement *)SoDiffuseColorElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_getNum" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  result = (int32_t)((SoDiffuseColorElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDiffuseColorElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_get" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDiffuseColorElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &((SoDiffuseColorElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_isPacked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_isPacked" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  result = (SbBool)((SoDiffuseColorElement const *)arg1)->isPacked();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_hasPackedTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_hasPackedTransparency" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  result = (SbBool)((SoDiffuseColorElement const *)arg1)->hasPackedTransparency();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getColorArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_getColorArrayPtr" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  result = (SbColor *)((SoDiffuseColorElement const *)arg1)->getColorArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDiffuseColorElement_getPackedArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDiffuseColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDiffuseColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDiffuseColorElement_getPackedArrayPtr" "', argument " "1"" of type '" "SoDiffuseColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDiffuseColorElement * >(argp1);
  result = (uint32_t *)((SoDiffuseColorElement const *)arg1)->getPackedArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDiffuseColorElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDiffuseColorElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLClipPlaneElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLClipPlaneElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLClipPlaneElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLClipPlaneElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLClipPlaneElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLClipPlaneElement_init" "', argument " "1"" of type '" "SoGLClipPlaneElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLClipPlaneElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLClipPlaneElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLClipPlaneElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLClipPlaneElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLClipPlaneElement_pop" "', argument " "1"" of type '" "SoGLClipPlaneElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLClipPlaneElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLClipPlaneElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLClipPlaneElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLClipPlaneElement_getMaxGLPlanes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLClipPlaneElement_getMaxGLPlanes", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLClipPlaneElement::getMaxGLPlanes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLClipPlaneElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLClipPlaneElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLightElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLightElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLightElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLightElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLightElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightElement_init" "', argument " "1"" of type '" "SoLightElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLightElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightElement_push" "', argument " "1"" of type '" "SoLightElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLightElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoLight *arg2 = (SoLight *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightElement_add" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightElement_add" "', argument " "2"" of type '" "SoLight *const""'"); 
  }
  arg2 = reinterpret_cast< SoLight * >(argp2);
  SoLightElement::add(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_getLights(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodeList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightElement_getLights" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoNodeList *) &SoLightElement::getLights(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightElement_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightElement_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightElement_getMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightElement_getMatrix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbMatrix *) &SoLightElement::getMatrix(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLModelMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLModelMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLModelMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLModelMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLModelMatrixElement_init" "', argument " "1"" of type '" "SoGLModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLModelMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLModelMatrixElement_push" "', argument " "1"" of type '" "SoGLModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLModelMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLModelMatrixElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLModelMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLModelMatrixElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLModelMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLModelMatrixElement_pop" "', argument " "1"" of type '" "SoGLModelMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLModelMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLModelMatrixElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLModelMatrixElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLModelMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLModelMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoProfileElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProfileElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoProfileElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoProfileElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_initClass", 0, 0, 0)) SWIG_fail;
  SoProfileElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileElement_init" "', argument " "1"" of type '" "SoProfileElement *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileElement_push" "', argument " "1"" of type '" "SoProfileElement *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoProfile *arg2 = (SoProfile *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileElement_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileElement_add" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileElement_add" "', argument " "2"" of type '" "SoProfile *const""'"); 
  }
  arg2 = reinterpret_cast< SoProfile * >(argp2);
  SoProfileElement::add(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodeList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoNodeList *) &SoProfileElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProfileElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProfileElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMultiTextureMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoMultiTextureMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMultiTextureMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoMultiTextureMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_init" "', argument " "1"" of type '" "SoMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_push" "', argument " "1"" of type '" "SoMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  {
    arg4 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureMatrixElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureMatrixElement::set(arg1,arg2,arg3,(SbMatrix const &)*arg4);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg4, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_mult__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  {
    arg4 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_mult" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_mult" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureMatrixElement_mult" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureMatrixElement::mult(arg1,arg2,arg3,(SbMatrix const &)*arg4);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg4, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureMatrixElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbMatrix *) &SoMultiTextureMatrixElement::get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoMultiTextureMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureMatrixElement_get__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureMatrixElement_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureMatrixElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureMatrixElement::get(SoState *const,int const)\n"
    "    SoMultiTextureMatrixElement::get(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_makeIdentity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_makeIdentity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_makeIdentity" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureMatrixElement_makeIdentity" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureMatrixElement::makeIdentity(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_makeIdentity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_makeIdentity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_makeIdentity" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureMatrixElement::makeIdentity(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_makeIdentity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_makeIdentity", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureMatrixElement_makeIdentity__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureMatrixElement_makeIdentity__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureMatrixElement_makeIdentity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureMatrixElement::makeIdentity(SoState *const,SoNode *const,int const)\n"
    "    SoMultiTextureMatrixElement::makeIdentity(SoState *const,SoNode *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureMatrixElement::set(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureMatrixElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureMatrixElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureMatrixElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureMatrixElement::set(SoState *const,SoNode *const,int const,SbMatrix const &)\n"
    "    SoMultiTextureMatrixElement::set(SoState *const,SoNode *const,SbMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_mult__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_mult" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_mult" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureMatrixElement::mult(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_mult(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_mult", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureMatrixElement_mult__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureMatrixElement_mult__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureMatrixElement_mult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureMatrixElement::mult(SoState *const,SoNode *const,int const,SbMatrix const &)\n"
    "    SoMultiTextureMatrixElement::mult(SoState *const,SoNode *const,SbMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_translateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_translateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_translateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_translateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureMatrixElement_translateBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoMultiTextureMatrixElement::translateBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_rotateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_rotateBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_rotateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_rotateBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureMatrixElement_rotateBy" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  SoMultiTextureMatrixElement::rotateBy(arg1,arg2,(SbRotation const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureMatrixElement_scaleBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureMatrixElement_scaleBy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureMatrixElement_scaleBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureMatrixElement_scaleBy" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMultiTextureMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureMatrixElement_scaleBy" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoMultiTextureMatrixElement::scaleBy(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMultiTextureMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMultiTextureMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLMultiTextureMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLMultiTextureMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLMultiTextureMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLMultiTextureMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureMatrixElement_init" "', argument " "1"" of type '" "SoGLMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureMatrixElement_push" "', argument " "1"" of type '" "SoGLMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureMatrixElement_pop" "', argument " "1"" of type '" "SoGLMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureMatrixElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureMatrixElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_multElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureMatrixElement *arg1 = 0 ;
  int arg2 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_multElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureMatrixElement_multElt" "', argument " "1"" of type '" "SoGLMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureMatrixElement_multElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->multElt(arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureMatrixElement_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureMatrixElement *arg1 = 0 ;
  int arg2 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureMatrixElement_setElt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureMatrixElement_setElt" "', argument " "1"" of type '" "SoGLMultiTextureMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureMatrixElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setElt(arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLMultiTextureMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLMultiTextureMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLDrawStyleElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLDrawStyleElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLDrawStyleElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLDrawStyleElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDrawStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDrawStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDrawStyleElement_init" "', argument " "1"" of type '" "SoGLDrawStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDrawStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDrawStyleElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDrawStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDrawStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDrawStyleElement_push" "', argument " "1"" of type '" "SoGLDrawStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDrawStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDrawStyleElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDrawStyleElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDrawStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDrawStyleElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDrawStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDrawStyleElement_pop" "', argument " "1"" of type '" "SoGLDrawStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDrawStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDrawStyleElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLDrawStyleElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLDrawStyleElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLDrawStyleElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLLightIdElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLLightIdElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLLightIdElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLLightIdElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLLightIdElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLightIdElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLightIdElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_init" "', argument " "1"" of type '" "SoGLLightIdElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLightIdElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLightIdElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLightIdElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLightIdElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_push" "', argument " "1"" of type '" "SoGLLightIdElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLightIdElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLightIdElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLightIdElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLightIdElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_pop" "', argument " "1"" of type '" "SoGLLightIdElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLightIdElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLightIdElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLightIdElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_increment" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLightIdElement_increment" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int32_t)SoGLLightIdElement::increment(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_increment" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoGLLightIdElement::increment(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLLightIdElement_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLLightIdElement_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLLightIdElement_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLLightIdElement::increment(SoState *const,SoNode *const)\n"
    "    SoGLLightIdElement::increment(SoState *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLightIdElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoGLLightIdElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoGLLightIdElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLightIdElement_getMaxGLSources(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLightIdElement_getMaxGLSources", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoGLLightIdElement::getMaxGLSources();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLLightIdElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLLightIdElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMultiTextureEnabledElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoMultiTextureEnabledElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMultiTextureEnabledElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_initClass", 0, 0, 0)) SWIG_fail;
  SoMultiTextureEnabledElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_init" "', argument " "1"" of type '" "SoMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoMultiTextureEnabledElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureEnabledElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoMultiTextureEnabledElement::get(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoMultiTextureEnabledElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureEnabledElement_get__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::get(SoState *,int const)\n"
    "    SoMultiTextureEnabledElement::get(SoState *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureEnabledElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_setElt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_setElt" "', argument " "1"" of type '" "SoMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureEnabledElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureEnabledElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_setElt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setElt(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_push" "', argument " "1"" of type '" "SoMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureEnabledElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_matches" "', argument " "1"" of type '" "SoMultiTextureEnabledElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoMultiTextureEnabledElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultiTextureEnabledElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_copyMatchInfo" "', argument " "1"" of type '" "SoMultiTextureEnabledElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultiTextureEnabledElement * >(argp1);
  result = (SoElement *)((SoMultiTextureEnabledElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getEnabledUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_getEnabledUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_getEnabledUnits" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_getEnabledUnits" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureEnabledElement_getEnabledUnits" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SbBool *)SoMultiTextureEnabledElement::getEnabledUnits(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getActiveUnits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoMultiTextureEnabledElement::Mode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_getActiveUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_getActiveUnits" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_getActiveUnits" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMultiTextureEnabledElement_getActiveUnits" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SoMultiTextureEnabledElement::Mode *)SoMultiTextureEnabledElement::getActiveUnits(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMultiTextureEnabledElement__Mode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableRectangle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableRectangle" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableRectangle" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_enableRectangle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureEnabledElement::enableRectangle(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableRectangle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableRectangle" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableRectangle" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureEnabledElement::enableRectangle(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableRectangle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_enableRectangle", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_enableRectangle__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureEnabledElement_enableRectangle__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_enableRectangle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::enableRectangle(SoState *,SoNode *,int const)\n"
    "    SoMultiTextureEnabledElement::enableRectangle(SoState *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableCubeMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableCubeMap" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableCubeMap" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_enableCubeMap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureEnabledElement::enableCubeMap(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableCubeMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableCubeMap" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableCubeMap" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureEnabledElement::enableCubeMap(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableCubeMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_enableCubeMap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_enableCubeMap__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureEnabledElement_enableCubeMap__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_enableCubeMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::enableCubeMap(SoState *,SoNode *,int const)\n"
    "    SoMultiTextureEnabledElement::enableCubeMap(SoState *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableTexture3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableTexture3" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableTexture3" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_enableTexture3" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMultiTextureEnabledElement::enableTexture3(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableTexture3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_enableTexture3" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_enableTexture3" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoMultiTextureEnabledElement::enableTexture3(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_enableTexture3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_enableTexture3", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_enableTexture3__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureEnabledElement_enableTexture3__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_enableTexture3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::enableTexture3(SoState *,SoNode *,int const)\n"
    "    SoMultiTextureEnabledElement::enableTexture3(SoState *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getMode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoMultiTextureEnabledElement::Mode result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_getMode" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureEnabledElement_getMode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoMultiTextureEnabledElement::Mode)SoMultiTextureEnabledElement::getMode(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getMode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoMultiTextureEnabledElement::Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_getMode" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoMultiTextureEnabledElement::Mode)SoMultiTextureEnabledElement::getMode(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_getMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_getMode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMultiTextureEnabledElement_getMode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_getMode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_getMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::getMode(SoState *,int const)\n"
    "    SoMultiTextureEnabledElement::getMode(SoState *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_disableAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_disableAll" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoMultiTextureEnabledElement::disableAll(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoMultiTextureEnabledElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMultiTextureEnabledElement_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoMultiTextureEnabledElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultiTextureEnabledElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMultiTextureEnabledElement_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMultiTextureEnabledElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMultiTextureEnabledElement_set__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMultiTextureEnabledElement_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMultiTextureEnabledElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMultiTextureEnabledElement::set(SoState *,SoNode *,int const,SbBool const)\n"
    "    SoMultiTextureEnabledElement::set(SoState *,SbBool const)\n"
    "    SoMultiTextureEnabledElement::set(SoState *,SoNode *,SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *SoMultiTextureEnabledElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMultiTextureEnabledElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLMultiTextureEnabledElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLMultiTextureEnabledElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLMultiTextureEnabledElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLMultiTextureEnabledElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureEnabledElement_init" "', argument " "1"" of type '" "SoGLMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureEnabledElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureEnabledElement_push" "', argument " "1"" of type '" "SoGLMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureEnabledElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureEnabledElement_pop" "', argument " "1"" of type '" "SoGLMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureEnabledElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureEnabledElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureEnabledElement_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureEnabledElement *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureEnabledElement_setElt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureEnabledElement_setElt" "', argument " "1"" of type '" "SoGLMultiTextureEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureEnabledElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureEnabledElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLMultiTextureEnabledElement_setElt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setElt(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLMultiTextureEnabledElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLMultiTextureEnabledElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLinePatternElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLinePatternElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLinePatternElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLinePatternElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLinePatternElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLinePatternElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLinePatternElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_init" "', argument " "1"" of type '" "SoLinePatternElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLinePatternElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLinePatternElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  int32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLinePatternElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLinePatternElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoLinePatternElement_set" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  SoLinePatternElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLinePatternElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLinePatternElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoLinePatternElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLinePatternElement_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLinePatternElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoLinePatternElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_set__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLinePatternElement_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoLinePatternElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoLinePatternElement_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoLinePatternElement_set__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoLinePatternElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoLinePatternElement_set__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoLinePatternElement_set__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoLinePatternElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLinePatternElement::set(SoState *const,SoNode *const,int32_t const,int32_t const)\n"
    "    SoLinePatternElement::set(SoState *const,SoNode *const,int32_t const)\n"
    "    SoLinePatternElement::set(SoState *const,int32_t const,int32_t const)\n"
    "    SoLinePatternElement::set(SoState *const,int32_t const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoLinePatternElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoLinePatternElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_getScaleFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinePatternElement_getScaleFactor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoLinePatternElement::getScaleFactor(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinePatternElement_getDefaultScaleFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinePatternElement_getDefaultScaleFactor", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoLinePatternElement::getDefaultScaleFactor();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLinePatternElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLinePatternElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLLinePatternElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLLinePatternElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLLinePatternElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLLinePatternElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLinePatternElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLinePatternElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLinePatternElement_init" "', argument " "1"" of type '" "SoGLLinePatternElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLinePatternElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLinePatternElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLinePatternElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLinePatternElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLinePatternElement_push" "', argument " "1"" of type '" "SoGLLinePatternElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLinePatternElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLinePatternElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLinePatternElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLinePatternElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLinePatternElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLinePatternElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLinePatternElement_pop" "', argument " "1"" of type '" "SoGLLinePatternElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLinePatternElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLinePatternElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLinePatternElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLLinePatternElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLLinePatternElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoSwitchElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSwitchElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoSwitchElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSwitchElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_initClass", 0, 0, 0)) SWIG_fail;
  SoSwitchElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitchElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitchElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitchElement_init" "', argument " "1"" of type '" "SoSwitchElement *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitchElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitchElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitchElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitchElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSwitchElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoSwitchElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitchElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSwitchElement_set" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoSwitchElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSwitchElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSwitchElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSwitchElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSwitchElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSwitchElement::set(SoState *const,SoNode *const,int32_t const)\n"
    "    SoSwitchElement::set(SoState *const,int32_t const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitchElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoSwitchElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitchElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitchElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoSwitchElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSwitchElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSwitchElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextOutlineEnabledElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextOutlineEnabledElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextOutlineEnabledElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextOutlineEnabledElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextOutlineEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextOutlineEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_init" "', argument " "1"" of type '" "SoTextOutlineEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextOutlineEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextOutlineEnabledElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextOutlineEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextOutlineEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_push" "', argument " "1"" of type '" "SoTextOutlineEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextOutlineEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextOutlineEnabledElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextOutlineEnabledElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextOutlineEnabledElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_pop" "', argument " "1"" of type '" "SoTextOutlineEnabledElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextOutlineEnabledElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextOutlineEnabledElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextOutlineEnabledElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextOutlineEnabledElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextOutlineEnabledElement_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoTextOutlineEnabledElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextOutlineEnabledElement_set" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoTextOutlineEnabledElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoTextOutlineEnabledElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoTextOutlineEnabledElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTextOutlineEnabledElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextOutlineEnabledElement::set(SoState *const,SoNode *const,SbBool const)\n"
    "    SoTextOutlineEnabledElement::set(SoState *const,SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextOutlineEnabledElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoTextOutlineEnabledElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextOutlineEnabledElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextOutlineEnabledElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoTextOutlineEnabledElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextOutlineEnabledElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextOutlineEnabledElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoUnitsElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoUnitsElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoUnitsElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoUnitsElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_initClass", 0, 0, 0)) SWIG_fail;
  SoUnitsElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnitsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUnitsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnitsElement_init" "', argument " "1"" of type '" "SoUnitsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoUnitsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnitsElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoUnitsElement::Units arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnitsElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUnitsElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoUnitsElement_set" "', argument " "3"" of type '" "SoUnitsElement::Units""'");
  } 
  arg3 = static_cast< SoUnitsElement::Units >(val3);
  SoUnitsElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoUnitsElement::Units arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnitsElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoUnitsElement_set" "', argument " "2"" of type '" "SoUnitsElement::Units""'");
  } 
  arg2 = static_cast< SoUnitsElement::Units >(val2);
  SoUnitsElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoUnitsElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoUnitsElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoUnitsElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoUnitsElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoUnitsElement::set(SoState *const,SoNode *const,SoUnitsElement::Units const)\n"
    "    SoUnitsElement::set(SoState *const,SoUnitsElement::Units const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoUnitsElement::Units result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUnitsElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoUnitsElement::Units)SoUnitsElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUnitsElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUnitsElement::Units result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUnitsElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoUnitsElement::Units)SoUnitsElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoUnitsElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoUnitsElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFocalDistanceElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoFocalDistanceElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoFocalDistanceElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_initClass", 0, 0, 0)) SWIG_fail;
  SoFocalDistanceElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFocalDistanceElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFocalDistanceElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFocalDistanceElement_init" "', argument " "1"" of type '" "SoFocalDistanceElement *""'"); 
  }
  arg1 = reinterpret_cast< SoFocalDistanceElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFocalDistanceElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFocalDistanceElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFocalDistanceElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFocalDistanceElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoFocalDistanceElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFocalDistanceElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFocalDistanceElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoFocalDistanceElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoFocalDistanceElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoFocalDistanceElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFocalDistanceElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFocalDistanceElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoFocalDistanceElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFocalDistanceElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoFocalDistanceElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFocalDistanceElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFocalDistanceElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoFocalDistanceElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFocalDistanceElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFocalDistanceElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoFontSizeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFontSizeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoFontSizeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoFontSizeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoFontSizeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontSizeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontSizeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontSizeElement_init" "', argument " "1"" of type '" "SoFontSizeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoFontSizeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontSizeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontSizeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontSizeElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFontSizeElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoFontSizeElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontSizeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFontSizeElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoFontSizeElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFontSizeElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoFontSizeElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoFontSizeElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFontSizeElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFontSizeElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoFontSizeElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontSizeElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoFontSizeElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontSizeElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontSizeElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoFontSizeElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFontSizeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFontSizeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLineWidthElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLineWidthElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLineWidthElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLineWidthElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLineWidthElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineWidthElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineWidthElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineWidthElement_init" "', argument " "1"" of type '" "SoLineWidthElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLineWidthElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineWidthElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineWidthElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineWidthElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLineWidthElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoLineWidthElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineWidthElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLineWidthElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoLineWidthElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoLineWidthElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoLineWidthElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoLineWidthElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoLineWidthElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLineWidthElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoLineWidthElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineWidthElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoLineWidthElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineWidthElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineWidthElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoLineWidthElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLineWidthElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLineWidthElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLLineWidthElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLLineWidthElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLLineWidthElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLLineWidthElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLineWidthElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLineWidthElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLineWidthElement_init" "', argument " "1"" of type '" "SoGLLineWidthElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLineWidthElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLineWidthElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLineWidthElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLineWidthElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLineWidthElement_push" "', argument " "1"" of type '" "SoGLLineWidthElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLineWidthElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLineWidthElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLLineWidthElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLLineWidthElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLLineWidthElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLLineWidthElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLLineWidthElement_pop" "', argument " "1"" of type '" "SoGLLineWidthElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLLineWidthElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLLineWidthElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLLineWidthElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLLineWidthElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLLineWidthElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoPointSizeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointSizeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoPointSizeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoPointSizeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoPointSizeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSizeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSizeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSizeElement_init" "', argument " "1"" of type '" "SoPointSizeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSizeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSizeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSizeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSizeElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPointSizeElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoPointSizeElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSizeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPointSizeElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoPointSizeElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPointSizeElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPointSizeElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoPointSizeElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPointSizeElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPointSizeElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoPointSizeElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSizeElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoPointSizeElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSizeElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSizeElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoPointSizeElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointSizeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointSizeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLPointSizeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLPointSizeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLPointSizeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLPointSizeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPointSizeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPointSizeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPointSizeElement_init" "', argument " "1"" of type '" "SoGLPointSizeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPointSizeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPointSizeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPointSizeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPointSizeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPointSizeElement_push" "', argument " "1"" of type '" "SoGLPointSizeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPointSizeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPointSizeElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPointSizeElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPointSizeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPointSizeElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPointSizeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPointSizeElement_pop" "', argument " "1"" of type '" "SoGLPointSizeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPointSizeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPointSizeElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLPointSizeElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLPointSizeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLPointSizeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTextureQualityElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureQualityElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextureQualityElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextureQualityElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureQualityElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureQualityElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureQualityElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureQualityElement_init" "', argument " "1"" of type '" "SoTextureQualityElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureQualityElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureQualityElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureQualityElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureQualityElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextureQualityElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoTextureQualityElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureQualityElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureQualityElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoTextureQualityElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoTextureQualityElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoTextureQualityElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTextureQualityElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTextureQualityElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoTextureQualityElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureQualityElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoTextureQualityElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureQualityElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureQualityElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (float)SoTextureQualityElement::getDefault();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureQualityElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureQualityElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureOverrideElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextureOverrideElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextureOverrideElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureOverrideElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureOverrideElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_matches" "', argument " "1"" of type '" "SoTextureOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureOverrideElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoTextureOverrideElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureOverrideElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_copyMatchInfo" "', argument " "1"" of type '" "SoTextureOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureOverrideElement * >(argp1);
  result = (SoElement *)((SoTextureOverrideElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureOverrideElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_init" "', argument " "1"" of type '" "SoTextureOverrideElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureOverrideElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureOverrideElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_push" "', argument " "1"" of type '" "SoTextureOverrideElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureOverrideElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_getQualityOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_getQualityOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoTextureOverrideElement::getQualityOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_getImageOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_getImageOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoTextureOverrideElement::getImageOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_getBumpMapOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_getBumpMapOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoTextureOverrideElement::getBumpMapOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_setQualityOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_setQualityOverride", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_setQualityOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureOverrideElement_setQualityOverride" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoTextureOverrideElement::setQualityOverride(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_setImageOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_setImageOverride", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_setImageOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureOverrideElement_setImageOverride" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoTextureOverrideElement::setImageOverride(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_setBumpMapOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_setBumpMapOverride", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_setBumpMapOverride" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureOverrideElement_setBumpMapOverride" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoTextureOverrideElement::setBumpMapOverride(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureOverrideElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureOverrideElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureOverrideElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureOverrideElement_output" "', argument " "1"" of type '" "SoTextureOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureOverrideElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoTextureOverrideElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureOverrideElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureOverrideElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLRenderPassElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLRenderPassElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLRenderPassElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLRenderPassElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderPassElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderPassElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderPassElement_init" "', argument " "1"" of type '" "SoGLRenderPassElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderPassElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderPassElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderPassElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderPassElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderPassElement_matches" "', argument " "1"" of type '" "SoGLRenderPassElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderPassElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLRenderPassElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoGLRenderPassElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderPassElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderPassElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderPassElement_copyMatchInfo" "', argument " "1"" of type '" "SoGLRenderPassElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderPassElement * >(argp1);
  result = (SoElement *)((SoGLRenderPassElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLRenderPassElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderPassElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLRenderPassElement_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGLRenderPassElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLRenderPassElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLRenderPassElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoGLRenderPassElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLRenderPassElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLRenderPassElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLUpdateAreaElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLUpdateAreaElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLUpdateAreaElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLUpdateAreaElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLUpdateAreaElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLUpdateAreaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_init" "', argument " "1"" of type '" "SoGLUpdateAreaElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLUpdateAreaElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLUpdateAreaElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLUpdateAreaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_push" "', argument " "1"" of type '" "SoGLUpdateAreaElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLUpdateAreaElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLUpdateAreaElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLUpdateAreaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_pop" "', argument " "1"" of type '" "SoGLUpdateAreaElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLUpdateAreaElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLUpdateAreaElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLUpdateAreaElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLUpdateAreaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_matches" "', argument " "1"" of type '" "SoGLUpdateAreaElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLUpdateAreaElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoGLUpdateAreaElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLUpdateAreaElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLUpdateAreaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_copyMatchInfo" "', argument " "1"" of type '" "SoGLUpdateAreaElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLUpdateAreaElement * >(argp1);
  result = (SoElement *)((SoGLUpdateAreaElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_set" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLUpdateAreaElement_set" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLUpdateAreaElement_set" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLUpdateAreaElement_set" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  SoGLUpdateAreaElement::set(arg1,(SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_get", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLUpdateAreaElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLUpdateAreaElement_get" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLUpdateAreaElement_get" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLUpdateAreaElement_get" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLUpdateAreaElement_get" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (SbBool)SoGLUpdateAreaElement::get(arg1,*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_getDefaultOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_getDefaultOrigin", 0, 0, 0)) SWIG_fail;
  result = SoGLUpdateAreaElement::getDefaultOrigin();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLUpdateAreaElement_getDefaultSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLUpdateAreaElement_getDefaultSize", 0, 0, 0)) SWIG_fail;
  result = SoGLUpdateAreaElement::getDefaultSize();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLUpdateAreaElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLUpdateAreaElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLocalBBoxMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLocalBBoxMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLocalBBoxMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLocalBBoxMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocalBBoxMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocalBBoxMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_init" "', argument " "1"" of type '" "SoLocalBBoxMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLocalBBoxMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocalBBoxMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocalBBoxMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_push" "', argument " "1"" of type '" "SoLocalBBoxMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLocalBBoxMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_makeIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_makeIdentity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLocalBBoxMatrixElement::makeIdentity(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLocalBBoxMatrixElement::set(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_mult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_mult" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLocalBBoxMatrixElement::mult(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_translateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_translateBy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_translateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_translateBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLocalBBoxMatrixElement_translateBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoLocalBBoxMatrixElement::translateBy(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_rotateBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_rotateBy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_rotateBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_rotateBy" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLocalBBoxMatrixElement_rotateBy" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  SoLocalBBoxMatrixElement::rotateBy(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_scaleBy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_scaleBy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_scaleBy" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_scaleBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLocalBBoxMatrixElement_scaleBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoLocalBBoxMatrixElement::scaleBy(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_pushMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_pushMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = SoLocalBBoxMatrixElement::pushMatrix(arg1);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_popMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_popMatrix" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLocalBBoxMatrixElement::popMatrix(arg1,(SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_resetAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_resetAll" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoLocalBBoxMatrixElement::resetAll(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoLocalBBoxMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocalBBoxMatrixElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocalBBoxMatrixElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocalBBoxMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_matches" "', argument " "1"" of type '" "SoLocalBBoxMatrixElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLocalBBoxMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocalBBoxMatrixElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoLocalBBoxMatrixElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocalBBoxMatrixElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocalBBoxMatrixElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocalBBoxMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocalBBoxMatrixElement_copyMatchInfo" "', argument " "1"" of type '" "SoLocalBBoxMatrixElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLocalBBoxMatrixElement * >(argp1);
  result = (SoElement *)((SoLocalBBoxMatrixElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLocalBBoxMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLocalBBoxMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoOverrideElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoOverrideElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoOverrideElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoOverrideElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_initClass", 0, 0, 0)) SWIG_fail;
  SoOverrideElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOverrideElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_init" "', argument " "1"" of type '" "SoOverrideElement *""'"); 
  }
  arg1 = reinterpret_cast< SoOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOverrideElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_push" "', argument " "1"" of type '" "SoOverrideElement *""'"); 
  }
  arg1 = reinterpret_cast< SoOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOverrideElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_matches" "', argument " "1"" of type '" "SoOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoOverrideElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoOverrideElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOverrideElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_copyMatchInfo" "', argument " "1"" of type '" "SoOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoOverrideElement * >(argp1);
  result = (SoElement *)((SoOverrideElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getFlags" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (uint32_t)SoOverrideElement::getFlags(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getAmbientColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getAmbientColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getAmbientColorOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getColorIndexOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getColorIndexOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getColorIndexOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getComplexityOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getComplexityOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getComplexityOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getComplexityTypeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getComplexityTypeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getComplexityTypeOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getCreaseAngleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getCreaseAngleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getCreaseAngleOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getDiffuseColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getDiffuseColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getDiffuseColorOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getDrawStyleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getDrawStyleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getDrawStyleOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getEmissiveColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getEmissiveColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getEmissiveColorOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getFontNameOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getFontNameOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getFontNameOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getFontSizeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getFontSizeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getFontSizeOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getLightModelOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getLightModelOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getLightModelOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getLinePatternOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getLinePatternOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getLinePatternOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getLineWidthOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getLineWidthOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getLineWidthOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getMaterialBindingOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getMaterialBindingOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getMaterialBindingOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getPickStyleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getPickStyleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getPickStyleOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getPointSizeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getPointSizeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getPointSizeOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getPolygonOffsetOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getPolygonOffsetOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getPolygonOffsetOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getShapeHintsOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getShapeHintsOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getShapeHintsOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getShininessOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getShininessOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getShininessOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getSpecularColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getSpecularColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getSpecularColorOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getTransparencyOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getTransparencyOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getTransparencyOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getTransparencyTypeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getTransparencyTypeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getTransparencyTypeOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getNormalVectorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getNormalVectorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getNormalVectorOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_getNormalBindingOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_getNormalBindingOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoOverrideElement::getNormalBindingOverride(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setAmbientColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setAmbientColorOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setAmbientColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setAmbientColorOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setAmbientColorOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setAmbientColorOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setColorIndexOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setColorIndexOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setColorIndexOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setColorIndexOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setColorIndexOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setColorIndexOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setComplexityOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setComplexityOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setComplexityOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setComplexityOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setComplexityOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setComplexityOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setComplexityTypeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setComplexityTypeOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setComplexityTypeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setComplexityTypeOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setComplexityTypeOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setComplexityTypeOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setCreaseAngleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setCreaseAngleOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setCreaseAngleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setCreaseAngleOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setCreaseAngleOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setCreaseAngleOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setDiffuseColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setDiffuseColorOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setDiffuseColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setDiffuseColorOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setDiffuseColorOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setDiffuseColorOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setDrawStyleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setDrawStyleOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setDrawStyleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setDrawStyleOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setDrawStyleOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setDrawStyleOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setEmissiveColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setEmissiveColorOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setEmissiveColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setEmissiveColorOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setEmissiveColorOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setEmissiveColorOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setFontNameOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setFontNameOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setFontNameOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setFontNameOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setFontNameOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setFontNameOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setFontSizeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setFontSizeOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setFontSizeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setFontSizeOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setFontSizeOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setFontSizeOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setLightModelOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setLightModelOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setLightModelOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setLightModelOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setLightModelOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setLightModelOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setLinePatternOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setLinePatternOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setLinePatternOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setLinePatternOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setLinePatternOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setLinePatternOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setLineWidthOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setLineWidthOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setLineWidthOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setLineWidthOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setLineWidthOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setLineWidthOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setMaterialBindingOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setMaterialBindingOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setMaterialBindingOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setMaterialBindingOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setMaterialBindingOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setMaterialBindingOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setPickStyleOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setPickStyleOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setPickStyleOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setPickStyleOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setPickStyleOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setPickStyleOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setPointSizeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setPointSizeOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setPointSizeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setPointSizeOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setPointSizeOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setPointSizeOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setPolygonOffsetOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setPolygonOffsetOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setPolygonOffsetOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setPolygonOffsetOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setPolygonOffsetOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setPolygonOffsetOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setShapeHintsOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setShapeHintsOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setShapeHintsOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setShapeHintsOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setShapeHintsOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setShapeHintsOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setShininessOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setShininessOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setShininessOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setShininessOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setShininessOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setShininessOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setSpecularColorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setSpecularColorOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setSpecularColorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setSpecularColorOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setSpecularColorOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setSpecularColorOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setTransparencyOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setTransparencyOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setTransparencyOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setTransparencyOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setTransparencyOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setTransparencyOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setTransparencyTypeOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setTransparencyTypeOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setTransparencyTypeOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setTransparencyTypeOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setTransparencyTypeOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setTransparencyTypeOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setNormalVectorOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setNormalVectorOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setNormalVectorOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setNormalVectorOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setNormalVectorOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setNormalVectorOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_setNormalBindingOverride(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_setNormalBindingOverride", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_setNormalBindingOverride" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOverrideElement_setNormalBindingOverride" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOverrideElement_setNormalBindingOverride" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoOverrideElement::setNormalBindingOverride(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOverrideElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOverrideElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOverrideElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOverrideElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOverrideElement_output" "', argument " "1"" of type '" "SoOverrideElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoOverrideElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoOverrideElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOverrideElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOverrideElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoPickRayElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPickRayElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoPickRayElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoPickRayElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_initClass", 0, 0, 0)) SWIG_fail;
  SoPickRayElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickRayElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickRayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickRayElement_init" "', argument " "1"" of type '" "SoPickRayElement *""'"); 
  }
  arg1 = reinterpret_cast< SoPickRayElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickRayElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickRayElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickRayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickRayElement_matches" "', argument " "1"" of type '" "SoPickRayElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickRayElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickRayElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoPickRayElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickRayElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickRayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickRayElement_copyMatchInfo" "', argument " "1"" of type '" "SoPickRayElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickRayElement * >(argp1);
  result = (SoElement *)((SoPickRayElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbViewVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickRayElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickRayElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewVolume,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickRayElement_set" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickRayElement_set" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewVolume * >(argp2);
  SoPickRayElement::set(arg1,(SbViewVolume const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickRayElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickRayElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbViewVolume *) &SoPickRayElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickRayElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickRayElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_getPtr3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCoordinateElement_getPtr3" "', argument " "1"" of type '" "SoGLCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCoordinateElement * >(argp1);
  result = (SbVec3f *)((SoGLCoordinateElement const *)arg1)->getPtr3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_getPtr4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCoordinateElement_getPtr4" "', argument " "1"" of type '" "SoGLCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCoordinateElement * >(argp1);
  result = (SbVec4f *)((SoGLCoordinateElement const *)arg1)->getPtr4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCoordinateElement_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCoordinateElement_send", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCoordinateElement_send" "', argument " "1"" of type '" "SoGLCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLCoordinateElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoGLCoordinateElement const *)arg1)->send(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEnvironmentElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoEnvironmentElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoEnvironmentElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_initClass", 0, 0, 0)) SWIG_fail;
  SoEnvironmentElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironmentElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironmentElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_init" "', argument " "1"" of type '" "SoEnvironmentElement *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironmentElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironmentElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  SbColor *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  int32_t arg6 ;
  SbColor *arg7 = 0 ;
  float arg8 ;
  float arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironmentElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEnvironmentElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEnvironmentElement_set" "', argument " "4"" of type '" "SbColor const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "4"" of type '" "SbColor const &""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEnvironmentElement_set" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoEnvironmentElement_set" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoEnvironmentElement_set" "', argument " "7"" of type '" "SbColor const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "7"" of type '" "SbColor const &""'"); 
  }
  arg7 = reinterpret_cast< SbColor * >(argp7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoEnvironmentElement_set" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_float(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoEnvironmentElement_set" "', argument " "9"" of type '" "float""'");
  } 
  arg9 = static_cast< float >(val9);
  SoEnvironmentElement::set(arg1,arg2,arg3,(SbColor const &)*arg4,(SbVec3f const &)*arg5,arg6,(SbColor const &)*arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  SbColor *arg4 = 0 ;
  SbVec3f *arg5 = 0 ;
  int32_t arg6 ;
  SbColor *arg7 = 0 ;
  float arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironmentElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEnvironmentElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEnvironmentElement_set" "', argument " "4"" of type '" "SbColor const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "4"" of type '" "SbColor const &""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEnvironmentElement_set" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "5"" of type '" "SbVec3f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3f * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoEnvironmentElement_set" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoEnvironmentElement_set" "', argument " "7"" of type '" "SbColor const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_set" "', argument " "7"" of type '" "SbColor const &""'"); 
  }
  arg7 = reinterpret_cast< SbColor * >(argp7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoEnvironmentElement_set" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  SoEnvironmentElement::set(arg1,arg2,arg3,(SbColor const &)*arg4,(SbVec3f const &)*arg5,arg6,(SbColor const &)*arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_set", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SoEnvironmentElement_set__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SoEnvironmentElement_set__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEnvironmentElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEnvironmentElement::set(SoState *const,SoNode *const,float const,SbColor const &,SbVec3f const &,int32_t const,SbColor const &,float const,float const)\n"
    "    SoEnvironmentElement::set(SoState *const,SoNode *const,float const,SbColor const &,SbVec3f const &,int32_t const,SbColor const &,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float *arg2 = 0 ;
  SbColor *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  int32_t *arg5 = 0 ;
  SbColor *arg6 = 0 ;
  float *arg7 = 0 ;
  float *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_get", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironmentElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEnvironmentElement_get" "', argument " "3"" of type '" "SbColor &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "3"" of type '" "SbColor &""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEnvironmentElement_get" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEnvironmentElement_get" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  arg5 = reinterpret_cast< int32_t * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoEnvironmentElement_get" "', argument " "6"" of type '" "SbColor &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "6"" of type '" "SbColor &""'"); 
  }
  arg6 = reinterpret_cast< SbColor * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoEnvironmentElement_get" "', argument " "7"" of type '" "float &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "7"" of type '" "float &""'"); 
  }
  arg7 = reinterpret_cast< float * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoEnvironmentElement_get" "', argument " "8"" of type '" "float &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_get" "', argument " "8"" of type '" "float &""'"); 
  }
  arg8 = reinterpret_cast< float * >(argp8);
  SoEnvironmentElement::get(arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getAmbientIntensity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getAmbientIntensity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoEnvironmentElement::getAmbientIntensity(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getFogVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getFogVisibility" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoEnvironmentElement::getFogVisibility(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getLightAttenuation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getLightAttenuation" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbVec3f *) &SoEnvironmentElement::getLightAttenuation(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getAmbientColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getAmbientColor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoEnvironmentElement::getAmbientColor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getFogColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getFogColor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbColor *) &SoEnvironmentElement::getFogColor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getFogType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getFogType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int32_t)SoEnvironmentElement::getFogType(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  SbColor *arg5 = 0 ;
  float *arg6 = 0 ;
  float *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_getDefault", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_getDefault" "', argument " "1"" of type '" "float &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "1"" of type '" "float &""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironmentElement_getDefault" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEnvironmentElement_getDefault" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEnvironmentElement_getDefault" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEnvironmentElement_getDefault" "', argument " "5"" of type '" "SbColor &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "5"" of type '" "SbColor &""'"); 
  }
  arg5 = reinterpret_cast< SbColor * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoEnvironmentElement_getDefault" "', argument " "6"" of type '" "float &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "6"" of type '" "float &""'"); 
  }
  arg6 = reinterpret_cast< float * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoEnvironmentElement_getDefault" "', argument " "7"" of type '" "float &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEnvironmentElement_getDefault" "', argument " "7"" of type '" "float &""'"); 
  }
  arg7 = reinterpret_cast< float * >(argp7);
  SoEnvironmentElement::getDefault(*arg1,*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironmentElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironmentElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironmentElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironmentElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironmentElement_output" "', argument " "1"" of type '" "SoEnvironmentElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironmentElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoEnvironmentElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEnvironmentElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEnvironmentElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLEnvironmentElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLEnvironmentElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLEnvironmentElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLEnvironmentElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLEnvironmentElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLEnvironmentElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLEnvironmentElement_init" "', argument " "1"" of type '" "SoGLEnvironmentElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLEnvironmentElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLEnvironmentElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLEnvironmentElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLEnvironmentElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLEnvironmentElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLEnvironmentElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLEnvironmentElement_pop" "', argument " "1"" of type '" "SoGLEnvironmentElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLEnvironmentElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLEnvironmentElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLEnvironmentElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLEnvironmentElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLEnvironmentElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoFontNameElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFontNameElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoFontNameElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoFontNameElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_initClass", 0, 0, 0)) SWIG_fail;
  SoFontNameElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontNameElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontNameElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_init" "', argument " "1"" of type '" "SoFontNameElement *""'"); 
  }
  arg1 = reinterpret_cast< SoFontNameElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontNameElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbName arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontNameElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2])){
      arg3 = SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg3 = *namePtr;
    }
  }
  SoFontNameElement::set(arg1,arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbName *) &SoFontNameElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = SoFontNameElement::getDefault();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontNameElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontNameElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_matches" "', argument " "1"" of type '" "SoFontNameElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFontNameElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontNameElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoFontNameElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontNameElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontNameElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_copyMatchInfo" "', argument " "1"" of type '" "SoFontNameElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFontNameElement * >(argp1);
  result = (SoElement *)((SoFontNameElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontNameElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontNameElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontNameElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontNameElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontNameElement_output" "', argument " "1"" of type '" "SoFontNameElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoFontNameElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoFontNameElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFontNameElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFontNameElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLightAttenuationElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLightAttenuationElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLightAttenuationElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLightAttenuationElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightAttenuationElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightAttenuationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_init" "', argument " "1"" of type '" "SoLightAttenuationElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLightAttenuationElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightAttenuationElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightAttenuationElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoLightAttenuationElement_set" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLightAttenuationElement_set" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoLightAttenuationElement::set(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbVec3f *) &SoLightAttenuationElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SbVec3f *) &SoLightAttenuationElement::getDefault();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightAttenuationElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightAttenuationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_matches" "', argument " "1"" of type '" "SoLightAttenuationElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightAttenuationElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightAttenuationElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoLightAttenuationElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightAttenuationElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightAttenuationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_copyMatchInfo" "', argument " "1"" of type '" "SoLightAttenuationElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightAttenuationElement * >(argp1);
  result = (SoElement *)((SoLightAttenuationElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightAttenuationElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightAttenuationElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightAttenuationElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightAttenuationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightAttenuationElement_output" "', argument " "1"" of type '" "SoLightAttenuationElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightAttenuationElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoLightAttenuationElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightAttenuationElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightAttenuationElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPolygonOffsetElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoPolygonOffsetElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoPolygonOffsetElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_initClass", 0, 0, 0)) SWIG_fail;
  SoPolygonOffsetElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffsetElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffsetElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffsetElement_init" "', argument " "1"" of type '" "SoPolygonOffsetElement *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffsetElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffsetElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  float arg3 ;
  float arg4 ;
  SoPolygonOffsetElement::Style arg5 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_set", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffsetElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffsetElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPolygonOffsetElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPolygonOffsetElement_set" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoPolygonOffsetElement_set" "', argument " "5"" of type '" "SoPolygonOffsetElement::Style""'");
  } 
  arg5 = static_cast< SoPolygonOffsetElement::Style >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoPolygonOffsetElement_set" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  SoPolygonOffsetElement::set(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  SoPolygonOffsetElement::Style *arg4 = 0 ;
  SbBool *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_get", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffsetElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffsetElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPolygonOffsetElement_get" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_get" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoPolygonOffsetElement__Style,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoPolygonOffsetElement_get" "', argument " "4"" of type '" "SoPolygonOffsetElement::Style &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_get" "', argument " "4"" of type '" "SoPolygonOffsetElement::Style &""'"); 
  }
  arg4 = reinterpret_cast< SoPolygonOffsetElement::Style * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoPolygonOffsetElement_get" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_get" "', argument " "5"" of type '" "SbBool &""'"); 
  }
  arg5 = reinterpret_cast< SbBool * >(argp5);
  SoPolygonOffsetElement::get(arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffsetElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  float *arg2 = 0 ;
  SoPolygonOffsetElement::Style *arg3 = 0 ;
  SbBool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffsetElement_getDefault", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "1"" of type '" "float &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "1"" of type '" "float &""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoPolygonOffsetElement__Style,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "3"" of type '" "SoPolygonOffsetElement::Style &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "3"" of type '" "SoPolygonOffsetElement::Style &""'"); 
  }
  arg3 = reinterpret_cast< SoPolygonOffsetElement::Style * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPolygonOffsetElement_getDefault" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  arg4 = reinterpret_cast< SbBool * >(argp4);
  SoPolygonOffsetElement::getDefault(*arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPolygonOffsetElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPolygonOffsetElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLPolygonOffsetElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLPolygonOffsetElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLPolygonOffsetElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLPolygonOffsetElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPolygonOffsetElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPolygonOffsetElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPolygonOffsetElement_init" "', argument " "1"" of type '" "SoGLPolygonOffsetElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPolygonOffsetElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPolygonOffsetElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPolygonOffsetElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPolygonOffsetElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPolygonOffsetElement_push" "', argument " "1"" of type '" "SoGLPolygonOffsetElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPolygonOffsetElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPolygonOffsetElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLPolygonOffsetElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLPolygonOffsetElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLPolygonOffsetElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLPolygonOffsetElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLPolygonOffsetElement_pop" "', argument " "1"" of type '" "SoGLPolygonOffsetElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLPolygonOffsetElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLPolygonOffsetElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLPolygonOffsetElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLPolygonOffsetElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLPolygonOffsetElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProjectionMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoProjectionMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoProjectionMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoProjectionMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProjectionMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProjectionMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProjectionMatrixElement_init" "', argument " "1"" of type '" "SoProjectionMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoProjectionMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProjectionMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg3 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProjectionMatrixElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProjectionMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProjectionMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  SoProjectionMatrixElement::set(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg3, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProjectionMatrixElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProjectionMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoProjectionMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProjectionMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProjectionMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLProjectionMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLProjectionMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLProjectionMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLProjectionMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLProjectionMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLProjectionMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLProjectionMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLProjectionMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLProjectionMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLProjectionMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLProjectionMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLProjectionMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLProjectionMatrixElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLProjectionMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLProjectionMatrixElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLProjectionMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLProjectionMatrixElement_pop" "', argument " "1"" of type '" "SoGLProjectionMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLProjectionMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLProjectionMatrixElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLProjectionMatrixElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLProjectionMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLProjectionMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProfileCoordinateElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoProfileCoordinateElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoProfileCoordinateElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_initClass", 0, 0, 0)) SWIG_fail;
  SoProfileCoordinateElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_init" "', argument " "1"" of type '" "SoProfileCoordinateElement *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinateElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_set2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec2f *arg4 = (SbVec2f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_set2", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_set2" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinateElement_set2" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoProfileCoordinateElement_set2" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoProfileCoordinateElement_set2" "', argument " "4"" of type '" "SbVec2f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  SoProfileCoordinateElement::set2(arg1,arg2,arg3,(SbVec2f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_set3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbVec3f *arg4 = (SbVec3f *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_set3", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_set3" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinateElement_set3" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoProfileCoordinateElement_set3" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoProfileCoordinateElement_set3" "', argument " "4"" of type '" "SbVec3f const *const""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  SoProfileCoordinateElement::set3(arg1,arg2,arg3,(SbVec3f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProfileCoordinateElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoProfileCoordinateElement *)SoProfileCoordinateElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_getNum" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  result = (int32_t)((SoProfileCoordinateElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_get2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_get2", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_get2" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoProfileCoordinateElement_get2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &((SoProfileCoordinateElement const *)arg1)->get2(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_get3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_get3", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_get3" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoProfileCoordinateElement_get3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &((SoProfileCoordinateElement const *)arg1)->get3(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_is2D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_is2D" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  result = (SbBool)((SoProfileCoordinateElement const *)arg1)->is2D();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getDefault2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_getDefault2", 0, 0, 0)) SWIG_fail;
  result = SoProfileCoordinateElement::getDefault2();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getDefault3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinateElement_getDefault3", 0, 0, 0)) SWIG_fail;
  result = SoProfileCoordinateElement::getDefault3();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getArrayPtr2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_getArrayPtr2" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  result = (SbVec2f *)((SoProfileCoordinateElement const *)arg1)->getArrayPtr2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinateElement_getArrayPtr3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinateElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinateElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinateElement_getArrayPtr3" "', argument " "1"" of type '" "SoProfileCoordinateElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinateElement * >(argp1);
  result = (SbVec3f *)((SoProfileCoordinateElement const *)arg1)->getArrayPtr3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProfileCoordinateElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProfileCoordinateElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLMultiTextureImageElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLMultiTextureImageElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLMultiTextureImageElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLMultiTextureImageElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureImageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_init" "', argument " "1"" of type '" "SoGLMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureImageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_push" "', argument " "1"" of type '" "SoGLMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLMultiTextureImageElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLMultiTextureImageElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_pop" "', argument " "1"" of type '" "SoGLMultiTextureImageElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLMultiTextureImageElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureImageElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SoGLImage *arg4 = 0 ;
  SoMultiTextureImageElement::Model arg5 ;
  SbColor *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "4"" of type '" "SoGLImage *""'"); 
  }
  arg4 = reinterpret_cast< SoGLImage * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "5"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg5 = static_cast< SoMultiTextureImageElement::Model >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "6"" of type '" "SbColor const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_set" "', argument " "6"" of type '" "SbColor const &""'"); 
  }
  arg6 = reinterpret_cast< SbColor * >(argp6);
  SoGLMultiTextureImageElement::set(arg1,arg2,arg3,arg4,arg5,(SbColor const &)*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_restore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_restore", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_restore" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureImageElement_restore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGLMultiTextureImageElement::restore(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  SoMultiTextureImageElement::Model *arg3 = 0 ;
  SbColor *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SoGLImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "3"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_get" "', argument " "3"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg3 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "4"" of type '" "SbColor &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_get" "', argument " "4"" of type '" "SbColor &""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  result = (SoGLImage *)SoGLMultiTextureImageElement::get(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_hasTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_hasTransparency" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoGLMultiTextureImageElement::hasTransparency(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoGLImage *arg3 = 0 ;
  SoMultiTextureImageElement::Model arg4 ;
  SbColor *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "3"" of type '" "SoGLImage *""'"); 
  }
  arg3 = reinterpret_cast< SoGLImage * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "4"" of type '" "SoMultiTextureImageElement::Model""'");
  } 
  arg4 = static_cast< SoMultiTextureImageElement::Model >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLMultiTextureImageElement_set" "', argument " "5"" of type '" "SbColor const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_set" "', argument " "5"" of type '" "SbColor const &""'"); 
  }
  arg5 = reinterpret_cast< SbColor * >(argp5);
  SoGLMultiTextureImageElement::set(arg1,arg2,arg3,arg4,(SbColor const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_set", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoGLImage, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoGLMultiTextureImageElement_set__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoGLImage, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SoGLMultiTextureImageElement_set__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLMultiTextureImageElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLMultiTextureImageElement::set(SoState *const,SoNode *const,int const,SoGLImage *,SoMultiTextureImageElement::Model const,SbColor const &)\n"
    "    SoGLMultiTextureImageElement::set(SoState *const,SoNode *const,SoGLImage *,SoMultiTextureImageElement::Model const,SbColor const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoMultiTextureImageElement::Model *arg2 = 0 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SoGLImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMultiTextureImageElement__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "2"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_get" "', argument " "2"" of type '" "SoMultiTextureImageElement::Model &""'"); 
  }
  arg2 = reinterpret_cast< SoMultiTextureImageElement::Model * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLMultiTextureImageElement_get" "', argument " "3"" of type '" "SbColor &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLMultiTextureImageElement_get" "', argument " "3"" of type '" "SbColor &""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  result = (SoGLImage *)SoGLMultiTextureImageElement::get(arg1,*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_get", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLMultiTextureImageElement_get__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoMultiTextureImageElement__Model, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoGLMultiTextureImageElement_get__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLMultiTextureImageElement_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLMultiTextureImageElement::get(SoState *,int const,SoMultiTextureImageElement::Model &,SbColor &)\n"
    "    SoGLMultiTextureImageElement::get(SoState *,SoMultiTextureImageElement::Model &,SbColor &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLMultiTextureImageElement_getMaxGLTextureSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLMultiTextureImageElement_getMaxGLTextureSize", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoGLMultiTextureImageElement::getMaxGLTextureSize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLMultiTextureImageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLMultiTextureImageElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoViewingMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoViewingMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoViewingMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoViewingMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewingMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewingMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewingMatrixElement_init" "', argument " "1"" of type '" "SoViewingMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoViewingMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewingMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewingMatrixElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewingMatrixElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewingMatrixElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoViewingMatrixElement_set" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoViewingMatrixElement_set" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  SoViewingMatrixElement::set(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewingMatrixElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewingMatrixElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbMatrix *) &SoViewingMatrixElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoViewingMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoViewingMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLViewingMatrixElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLViewingMatrixElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLViewingMatrixElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLViewingMatrixElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewingMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewingMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewingMatrixElement_init" "', argument " "1"" of type '" "SoGLViewingMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewingMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewingMatrixElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewingMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewingMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewingMatrixElement_push" "', argument " "1"" of type '" "SoGLViewingMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewingMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewingMatrixElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewingMatrixElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewingMatrixElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewingMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewingMatrixElement_pop" "', argument " "1"" of type '" "SoGLViewingMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewingMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewingMatrixElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLViewingMatrixElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_getNodeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbUniqueId result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewingMatrixElement_getNodeId" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbUniqueId)SoGLViewingMatrixElement::getNodeId(arg1);
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewingMatrixElement_getResetMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewingMatrixElement_getResetMatrix" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = SoGLViewingMatrixElement::getResetMatrix(arg1);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLViewingMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLViewingMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoViewVolumeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoViewVolumeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoViewVolumeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoViewVolumeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoViewVolumeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewVolumeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewVolumeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewVolumeElement_init" "', argument " "1"" of type '" "SoViewVolumeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoViewVolumeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewVolumeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbViewVolume *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewVolumeElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewVolumeElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewVolumeElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewVolume,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoViewVolumeElement_set" "', argument " "3"" of type '" "SbViewVolume const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoViewVolumeElement_set" "', argument " "3"" of type '" "SbViewVolume const &""'"); 
  }
  arg3 = reinterpret_cast< SbViewVolume * >(argp3);
  SoViewVolumeElement::set(arg1,arg2,(SbViewVolume const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewVolumeElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewVolumeElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbViewVolume *) &SoViewVolumeElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoViewVolumeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoViewVolumeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLShapeHintsElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLShapeHintsElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLShapeHintsElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLShapeHintsElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_init" "', argument " "1"" of type '" "SoGLShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLShapeHintsElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_push" "', argument " "1"" of type '" "SoGLShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLShapeHintsElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLShapeHintsElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLShapeHintsElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_pop" "', argument " "1"" of type '" "SoGLShapeHintsElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLShapeHintsElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLShapeHintsElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLShapeHintsElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_forceSend__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoGLShapeHintsElement::forceSend(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_forceSend__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoGLShapeHintsElement::forceSend(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_forceSend__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLShapeHintsElement_forceSend" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoGLShapeHintsElement::forceSend(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLShapeHintsElement_forceSend(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLShapeHintsElement_forceSend", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGLShapeHintsElement_forceSend__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLShapeHintsElement_forceSend__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLShapeHintsElement_forceSend__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLShapeHintsElement_forceSend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLShapeHintsElement::forceSend(SoState *const,SbBool const)\n"
    "    SoGLShapeHintsElement::forceSend(SoState *const,SbBool const,SbBool const)\n"
    "    SoGLShapeHintsElement::forceSend(SoState *const,SbBool const,SbBool const,SbBool const)\n");
  return 0;
}


SWIGINTERN PyObject *SoGLShapeHintsElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLShapeHintsElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoShapeStyleElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShapeStyleElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoShapeStyleElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoShapeStyleElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_initClass", 0, 0, 0)) SWIG_fail;
  SoShapeStyleElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_init" "', argument " "1"" of type '" "SoShapeStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeStyleElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_push" "', argument " "1"" of type '" "SoShapeStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeStyleElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_pop" "', argument " "1"" of type '" "SoShapeStyleElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeStyleElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShapeStyleElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_matches" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShapeStyleElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoShapeStyleElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_copyMatchInfo" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (SoElement *)((SoShapeStyleElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShapeStyleElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoShapeStyleElement *)SoShapeStyleElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_getFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_getFlags" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (unsigned int)((SoShapeStyleElement const *)arg1)->getFlags();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_mightNotRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_mightNotRender" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (SbBool)((SoShapeStyleElement const *)arg1)->mightNotRender();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_needNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_needNormals" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (SbBool)((SoShapeStyleElement const *)arg1)->needNormals();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_needTexCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_needTexCoords" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (SbBool)((SoShapeStyleElement const *)arg1)->needTexCoords();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_getRenderCaseMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_getRenderCaseMask" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (int)((SoShapeStyleElement const *)arg1)->getRenderCaseMask();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setDrawStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setDrawStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setDrawStyle" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setDrawStyle" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoShapeStyleElement::setDrawStyle(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setComplexityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setComplexityType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setComplexityType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setComplexityType" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoShapeStyleElement::setComplexityType(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTransparencyType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTransparencyType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTransparencyType" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoShapeStyleElement::setTransparencyType(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTextureEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTextureEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTextureEnabled" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTextureEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setTextureEnabled(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTexture3Enabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTexture3Enabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTexture3Enabled" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTexture3Enabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setTexture3Enabled(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTextureFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTextureFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTextureFunction" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTextureFunction" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setTextureFunction(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setLightModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setLightModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setLightModel" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setLightModel" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  SoShapeStyleElement::setLightModel(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setOverrides(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setOverrides", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setOverrides" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setOverrides" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setOverrides(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_isScreenDoor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_isScreenDoor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoShapeStyleElement::isScreenDoor(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_getTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_getTransparencyType" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoShapeStyleElement::getTransparencyType(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_isTextureFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeStyleElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeStyleElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_isTextureFunction" "', argument " "1"" of type '" "SoShapeStyleElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeStyleElement * >(argp1);
  result = (SbBool)((SoShapeStyleElement const *)arg1)->isTextureFunction();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setBumpmapEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setBumpmapEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setBumpmapEnabled" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setBumpmapEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setBumpmapEnabled(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setBigImageEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setBigImageEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setBigImageEnabled" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setBigImageEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setBigImageEnabled(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setVertexArrayRendering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setVertexArrayRendering", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setVertexArrayRendering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setVertexArrayRendering" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setVertexArrayRendering(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTransparentMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTransparentMaterial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTransparentMaterial" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTransparentMaterial" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setTransparentMaterial(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setTransparentTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setTransparentTexture", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setTransparentTexture" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setTransparentTexture" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setTransparentTexture(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setShadowMapRendering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setShadowMapRendering", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setShadowMapRendering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setShadowMapRendering" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setShadowMapRendering(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeStyleElement_setShadowsRendering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeStyleElement_setShadowsRendering", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeStyleElement_setShadowsRendering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShapeStyleElement_setShadowsRendering" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  SoShapeStyleElement::setShadowsRendering(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShapeStyleElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShapeStyleElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoViewportRegionElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoViewportRegionElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoViewportRegionElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoViewportRegionElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_initClass", 0, 0, 0)) SWIG_fail;
  SoViewportRegionElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewportRegionElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_init" "', argument " "1"" of type '" "SoViewportRegionElement *""'"); 
  }
  arg1 = reinterpret_cast< SoViewportRegionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewportRegionElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewportRegionElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_matches" "', argument " "1"" of type '" "SoViewportRegionElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoViewportRegionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewportRegionElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoViewportRegionElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewportRegionElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_copyMatchInfo" "', argument " "1"" of type '" "SoViewportRegionElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoViewportRegionElement * >(argp1);
  result = (SoElement *)((SoViewportRegionElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoViewportRegionElement_set" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoViewportRegionElement_set" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  SoViewportRegionElement::set(arg1,(SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbViewportRegion *) &SoViewportRegionElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoViewportRegionElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoViewportRegionElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoViewportRegionElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoViewportRegionElement_output" "', argument " "1"" of type '" "SoViewportRegionElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoViewportRegionElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoViewportRegionElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoViewportRegionElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoViewportRegionElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLViewportRegionElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLViewportRegionElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLViewportRegionElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLViewportRegionElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewportRegionElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewportRegionElement_init" "', argument " "1"" of type '" "SoGLViewportRegionElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewportRegionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewportRegionElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewportRegionElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewportRegionElement_push" "', argument " "1"" of type '" "SoGLViewportRegionElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewportRegionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewportRegionElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLViewportRegionElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLViewportRegionElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLViewportRegionElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLViewportRegionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLViewportRegionElement_pop" "', argument " "1"" of type '" "SoGLViewportRegionElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLViewportRegionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLViewportRegionElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLViewportRegionElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLViewportRegionElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLViewportRegionElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoWindowElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoWindowElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoWindowElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoWindowElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_initClass", 0, 0, 0)) SWIG_fail;
  SoWindowElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWindowElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWindowElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_init" "', argument " "1"" of type '" "SoWindowElement *""'"); 
  }
  arg1 = reinterpret_cast< SoWindowElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWindowElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWindowElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_push" "', argument " "1"" of type '" "SoWindowElement *""'"); 
  }
  arg1 = reinterpret_cast< SoWindowElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWindowElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWindowElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_pop" "', argument " "1"" of type '" "SoWindowElement *""'"); 
  }
  arg1 = reinterpret_cast< SoWindowElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoWindowElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWindowElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWindowElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_matches" "', argument " "1"" of type '" "SoWindowElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoWindowElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoWindowElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWindowElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWindowElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_copyMatchInfo" "', argument " "1"" of type '" "SoWindowElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoWindowElement * >(argp1);
  result = (SoElement *)((SoWindowElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *arg2 = 0 ;
  void *arg3 = 0 ;
  void *arg4 = 0 ;
  SoGLRenderAction *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_set", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_set" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoWindowElement_set" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoWindowElement_set" "', argument " "4"" of type '" "void *""'"); 
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoWindowElement_set" "', argument " "5"" of type '" "SoGLRenderAction *""'"); 
  }
  arg5 = reinterpret_cast< SoGLRenderAction * >(argp5);
  SoWindowElement::set(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWindowElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void **arg2 = 0 ;
  void **arg3 = 0 ;
  void **arg4 = 0 ;
  SoGLRenderAction **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWindowElement_get", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWindowElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWindowElement_get" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWindowElement_get" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoWindowElement_get" "', argument " "3"" of type '" "void *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWindowElement_get" "', argument " "3"" of type '" "void *&""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoWindowElement_get" "', argument " "4"" of type '" "void *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWindowElement_get" "', argument " "4"" of type '" "void *&""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_SoGLRenderAction,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoWindowElement_get" "', argument " "5"" of type '" "SoGLRenderAction *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWindowElement_get" "', argument " "5"" of type '" "SoGLRenderAction *&""'"); 
  }
  arg5 = reinterpret_cast< SoGLRenderAction ** >(argp5);
  SoWindowElement::get(arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoWindowElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoWindowElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLCacheContextElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLCacheContextElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLCacheContextElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLCacheContextElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCacheContextElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCacheContextElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_init" "', argument " "1"" of type '" "SoGLCacheContextElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCacheContextElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLCacheContextElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCacheContextElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCacheContextElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_matches" "', argument " "1"" of type '" "SoGLCacheContextElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCacheContextElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLCacheContextElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoGLCacheContextElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLCacheContextElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLCacheContextElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_copyMatchInfo" "', argument " "1"" of type '" "SoGLCacheContextElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLCacheContextElement * >(argp1);
  result = (SoElement *)((SoGLCacheContextElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLCacheContextElement_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLCacheContextElement_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLCacheContextElement_set" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoGLCacheContextElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoGLCacheContextElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getExtID(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_getExtID" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)SoGLCacheContextElement::getExtID((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getOpenGLVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_getOpenGLVersion", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_getOpenGLVersion" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLCacheContextElement_getOpenGLVersion" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLCacheContextElement_getOpenGLVersion" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLCacheContextElement_getOpenGLVersion" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLCacheContextElement_getOpenGLVersion" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  SoGLCacheContextElement::getOpenGLVersion(arg1,*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_extSupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_extSupported", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_extSupported" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLCacheContextElement_extSupported" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoGLCacheContextElement::extSupported(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_areMipMapsFast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_areMipMapsFast" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoGLCacheContextElement::areMipMapsFast(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_shouldAutoCache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_shouldAutoCache", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_shouldAutoCache" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLCacheContextElement_shouldAutoCache" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGLCacheContextElement::shouldAutoCache(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_setAutoCacheBits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_setAutoCacheBits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_setAutoCacheBits" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLCacheContextElement_setAutoCacheBits" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoGLCacheContextElement::setAutoCacheBits(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_resetAutoCacheBits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_resetAutoCacheBits" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoGLCacheContextElement::resetAutoCacheBits(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getIsRemoteRendering(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_getIsRemoteRendering" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoGLCacheContextElement::getIsRemoteRendering(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getUniqueCacheContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_getUniqueCacheContext", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoGLCacheContextElement::getUniqueCacheContext();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_scheduleDeleteCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  SoScheduleDeleteCB *arg2 = 0 ;
  void *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLCacheContextElement_scheduleDeleteCallback", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoGLCacheContextElement_scheduleDeleteCallback" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_unsigned_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLCacheContextElement_scheduleDeleteCallback" "', argument " "2"" of type '" "SoScheduleDeleteCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLCacheContextElement_scheduleDeleteCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  SoGLCacheContextElement::scheduleDeleteCallback(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_incNumShapes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_incNumShapes" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLCacheContextElement::incNumShapes(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getNumShapes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_getNumShapes" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoGLCacheContextElement::getNumShapes(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_incNumSeparators(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_incNumSeparators" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLCacheContextElement::incNumSeparators(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLCacheContextElement_getNumSeparators(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLCacheContextElement_getNumSeparators" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoGLCacheContextElement::getNumSeparators(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLCacheContextElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLCacheContextElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoGLDisplayList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLDisplayList::Type arg2 ;
  int arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SoGLDisplayList *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGLDisplayList" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList::Type""'");
  } 
  arg2 = static_cast< SoGLDisplayList::Type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SoGLDisplayList" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SoGLDisplayList" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SoGLDisplayList *)new SoGLDisplayList(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLDisplayList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGLDisplayList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLDisplayList::Type arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoGLDisplayList *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGLDisplayList" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList::Type""'");
  } 
  arg2 = static_cast< SoGLDisplayList::Type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SoGLDisplayList" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoGLDisplayList *)new SoGLDisplayList(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLDisplayList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGLDisplayList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLDisplayList::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SoGLDisplayList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGLDisplayList" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SoGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList::Type""'");
  } 
  arg2 = static_cast< SoGLDisplayList::Type >(val2);
  result = (SoGLDisplayList *)new SoGLDisplayList(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLDisplayList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGLDisplayList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoGLDisplayList", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SoGLDisplayList__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SoGLDisplayList__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SoGLDisplayList__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoGLDisplayList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLDisplayList::SoGLDisplayList(SoState *,SoGLDisplayList::Type,int,SbBool)\n"
    "    SoGLDisplayList::SoGLDisplayList(SoState *,SoGLDisplayList::Type,int)\n"
    "    SoGLDisplayList::SoGLDisplayList(SoState *,SoGLDisplayList::Type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_ref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_ref" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  (arg1)->ref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_unref__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_unref" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_unref" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->unref(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_unref__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_unref" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  (arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_unref(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLDisplayList_unref", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLDisplayList_unref__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLDisplayList_unref__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLDisplayList_unref'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLDisplayList::unref(SoState *)\n"
    "    SoGLDisplayList::unref()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_open__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_open" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_open" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLDisplayList_open" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->open(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_open__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_open" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_open" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->open(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_open(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLDisplayList_open", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLDisplayList_open__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLDisplayList_open__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLDisplayList_open'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLDisplayList::open(SoState *,int)\n"
    "    SoGLDisplayList::open(SoState *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDisplayList_close", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_close" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_close" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->close(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_call__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_call" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_call" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLDisplayList_call" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->call(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_call__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_call" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_call" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->call(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_call(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLDisplayList_call", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLDisplayList_call__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLDisplayList_call__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLDisplayList_call'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLDisplayList::call(SoState *,int)\n"
    "    SoGLDisplayList::call(SoState *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_addDependency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDisplayList_addDependency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_addDependency" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDisplayList_addDependency" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->addDependency(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_isMipMapTextureObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_isMipMapTextureObject" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (SbBool)((SoGLDisplayList const *)arg1)->isMipMapTextureObject();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLDisplayList::Type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_getType" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (SoGLDisplayList::Type)((SoGLDisplayList const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_getNumAllocated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_getNumAllocated" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (int)((SoGLDisplayList const *)arg1)->getNumAllocated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_getFirstIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_getFirstIndex" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (unsigned int)((SoGLDisplayList const *)arg1)->getFirstIndex();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_getContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_getContext" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (int)((SoGLDisplayList const *)arg1)->getContext();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_setTextureTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDisplayList_setTextureTarget", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_setTextureTarget" "', argument " "1"" of type '" "SoGLDisplayList *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLDisplayList_setTextureTarget" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setTextureTarget(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDisplayList_getTextureTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDisplayList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDisplayList_getTextureTarget" "', argument " "1"" of type '" "SoGLDisplayList const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDisplayList * >(argp1);
  result = (int)((SoGLDisplayList const *)arg1)->getTextureTarget();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLDisplayList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLDisplayList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGLDisplayList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLColorIndexElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLColorIndexElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLColorIndexElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLColorIndexElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_isColorIndexMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_isColorIndexMode" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoGLColorIndexElement::isColorIndexMode(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLColorIndexElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLColorIndexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_init" "', argument " "1"" of type '" "SoGLColorIndexElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLColorIndexElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLColorIndexElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  int32_t *arg4 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLColorIndexElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLColorIndexElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLColorIndexElement_set" "', argument " "4"" of type '" "int32_t const *const""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  SoGLColorIndexElement::set(arg1,arg2,arg3,(int const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLColorIndexElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLColorIndexElement *)SoGLColorIndexElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLColorIndexElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLColorIndexElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLColorIndexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_getNum" "', argument " "1"" of type '" "SoGLColorIndexElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLColorIndexElement * >(argp1);
  result = (int32_t)((SoGLColorIndexElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLColorIndexElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLColorIndexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLColorIndexElement_get" "', argument " "1"" of type '" "SoGLColorIndexElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLColorIndexElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLColorIndexElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int32_t)((SoGLColorIndexElement const *)arg1)->get(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLColorIndexElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLColorIndexElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (int32_t)SoGLColorIndexElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLColorIndexElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLColorIndexElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoListenerPositionElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoListenerPositionElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoListenerPositionElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoListenerPositionElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_initClass", 0, 0, 0)) SWIG_fail;
  SoListenerPositionElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerPositionElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerPositionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerPositionElement_init" "', argument " "1"" of type '" "SoListenerPositionElement *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerPositionElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerPositionElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerPositionElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerPositionElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoListenerPositionElement_set" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoListenerPositionElement_set" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoListenerPositionElement_set" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoListenerPositionElement::set(arg1,arg2,(SbVec3f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerPositionElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbVec3f *) &SoListenerPositionElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_isSetByListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerPositionElement_isSetByListener" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoListenerPositionElement::isSetByListener(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerPositionElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerPositionElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerPositionElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerPositionElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerPositionElement_output" "', argument " "1"" of type '" "SoListenerPositionElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerPositionElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoListenerPositionElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoListenerPositionElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoListenerPositionElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoListenerOrientationElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoListenerOrientationElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoListenerOrientationElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_initClass", 0, 0, 0)) SWIG_fail;
  SoListenerOrientationElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerOrientationElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerOrientationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerOrientationElement_init" "', argument " "1"" of type '" "SoListenerOrientationElement *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerOrientationElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerOrientationElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbRotation *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerOrientationElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerOrientationElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoListenerOrientationElement_set" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoListenerOrientationElement_set" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoListenerOrientationElement_set" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoListenerOrientationElement::set(arg1,arg2,(SbRotation const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerOrientationElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbRotation *) &SoListenerOrientationElement::get(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_isSetByListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerOrientationElement_isSetByListener" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoListenerOrientationElement::isSetByListener(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerOrientationElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerOrientationElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerOrientationElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerOrientationElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerOrientationElement_output" "', argument " "1"" of type '" "SoListenerOrientationElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerOrientationElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoListenerOrientationElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoListenerOrientationElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoListenerOrientationElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoListenerDopplerElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoListenerDopplerElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoListenerDopplerElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_initClass", 0, 0, 0)) SWIG_fail;
  SoListenerDopplerElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerDopplerElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerDopplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_init" "', argument " "1"" of type '" "SoListenerDopplerElement *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerDopplerElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerDopplerElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_setDopplerVelocity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_setDopplerVelocity", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_setDopplerVelocity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerDopplerElement_setDopplerVelocity" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoListenerDopplerElement_setDopplerVelocity" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoListenerDopplerElement_setDopplerVelocity" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoListenerDopplerElement::setDopplerVelocity(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_setDopplerFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_setDopplerFactor", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_setDopplerFactor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerDopplerElement_setDopplerFactor" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoListenerDopplerElement_setDopplerFactor" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoListenerDopplerElement::setDopplerFactor(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_getDopplerVelocity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_getDopplerVelocity" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbVec3f *) &SoListenerDopplerElement::getDopplerVelocity(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_getDopplerFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_getDopplerFactor" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoListenerDopplerElement::getDopplerFactor(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerDopplerElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerDopplerElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerDopplerElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerDopplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerDopplerElement_output" "', argument " "1"" of type '" "SoListenerDopplerElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerDopplerElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoListenerDopplerElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoListenerDopplerElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoListenerDopplerElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoListenerGainElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerGainElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoListenerGainElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerGainElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoListenerGainElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerGainElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoListenerGainElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerGainElement_initClass", 0, 0, 0)) SWIG_fail;
  SoListenerGainElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListenerGainElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListenerGainElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListenerGainElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerGainElement_init" "', argument " "1"" of type '" "SoListenerGainElement *""'"); 
  }
  arg1 = reinterpret_cast< SoListenerGainElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerGainElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerGainElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListenerGainElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoListenerGainElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoListenerGainElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerGainElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoListenerGainElement_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoListenerGainElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoListenerGainElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoListenerGainElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoListenerGainElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoListenerGainElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoListenerGainElement::set(SoState *const,SoNode *const,float const)\n"
    "    SoListenerGainElement::set(SoState *const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoListenerGainElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListenerGainElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (float)SoListenerGainElement::get(arg1);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoListenerGainElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoListenerGainElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoSoundElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSoundElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoSoundElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSoundElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_initClass", 0, 0, 0)) SWIG_fail;
  SoSoundElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSoundElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSoundElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_init" "', argument " "1"" of type '" "SoSoundElement *""'"); 
  }
  arg1 = reinterpret_cast< SoSoundElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_set", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSoundElement_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSoundElement_set" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSoundElement_set" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  SoSoundElement::set(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_setSceneGraphHasSoundNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_setSceneGraphHasSoundNode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_setSceneGraphHasSoundNode" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_setSceneGraphHasSoundNode" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSoundElement_setSceneGraphHasSoundNode" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)SoSoundElement::setSceneGraphHasSoundNode(arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_sceneGraphHasSoundNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_sceneGraphHasSoundNode" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoSoundElement::sceneGraphHasSoundNode(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_setSoundNodeIsPlaying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_setSoundNodeIsPlaying", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_setSoundNodeIsPlaying" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_setSoundNodeIsPlaying" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSoundElement_setSoundNodeIsPlaying" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)SoSoundElement::setSoundNodeIsPlaying(arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_soundNodeIsPlaying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_soundNodeIsPlaying" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoSoundElement::soundNodeIsPlaying(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_setIsPartOfActiveSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_setIsPartOfActiveSceneGraph", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_setIsPartOfActiveSceneGraph" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_setIsPartOfActiveSceneGraph" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSoundElement_setIsPartOfActiveSceneGraph" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbBool)SoSoundElement::setIsPartOfActiveSceneGraph(arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_isPartOfActiveSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_isPartOfActiveSceneGraph" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoSoundElement::isPartOfActiveSceneGraph(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSoundElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSoundElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_push" "', argument " "1"" of type '" "SoSoundElement *""'"); 
  }
  arg1 = reinterpret_cast< SoSoundElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSoundElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSoundElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_pop" "', argument " "1"" of type '" "SoSoundElement *""'"); 
  }
  arg1 = reinterpret_cast< SoSoundElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSoundElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSoundElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSoundElement_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSoundElement *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSoundElement_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSoundElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSoundElement_output" "', argument " "1"" of type '" "SoSoundElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoSoundElement * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SoSoundElement const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSoundElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSoundElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLVBOElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLVBOElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLVBOElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLVBOElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLVBOElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_shouldCreateVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_shouldCreateVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_shouldCreateVBO" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLVBOElement_shouldCreateVBO" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoGLVBOElement::shouldCreateVBO(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_setVertexVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoVBO *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_setVertexVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_setVertexVBO" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_setVertexVBO" "', argument " "2"" of type '" "SoVBO *""'"); 
  }
  arg2 = reinterpret_cast< SoVBO * >(argp2);
  SoGLVBOElement::setVertexVBO(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_setNormalVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoVBO *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_setNormalVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_setNormalVBO" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_setNormalVBO" "', argument " "2"" of type '" "SoVBO *""'"); 
  }
  arg2 = reinterpret_cast< SoVBO * >(argp2);
  SoGLVBOElement::setNormalVBO(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_setColorVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoVBO *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_setColorVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_setColorVBO" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVBO, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_setColorVBO" "', argument " "2"" of type '" "SoVBO *""'"); 
  }
  arg2 = reinterpret_cast< SoVBO * >(argp2);
  SoGLVBOElement::setColorVBO(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_setTexCoordVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  SoVBO *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_setTexCoordVBO", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_setTexCoordVBO" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLVBOElement_setTexCoordVBO" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoVBO, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLVBOElement_setTexCoordVBO" "', argument " "3"" of type '" "SoVBO *""'"); 
  }
  arg3 = reinterpret_cast< SoVBO * >(argp3);
  SoGLVBOElement::setTexCoordVBO(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLVBOElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLVBOElement *)SoGLVBOElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_init" "', argument " "1"" of type '" "SoGLVBOElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_push" "', argument " "1"" of type '" "SoGLVBOElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_pop" "', argument " "1"" of type '" "SoGLVBOElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLVBOElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_matches" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVBOElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoGLVBOElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_copyMatchInfo" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  result = (SoElement *)((SoGLVBOElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getVertexVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVBO *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getVertexVBO" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  result = (SoVBO *)((SoGLVBOElement const *)arg1)->getVertexVBO();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVBO, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getNormalVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVBO *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getNormalVBO" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  result = (SoVBO *)((SoGLVBOElement const *)arg1)->getNormalVBO();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVBO, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getColorVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVBO *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getColorVBO" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  result = (SoVBO *)((SoGLVBOElement const *)arg1)->getColorVBO();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVBO, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getNumTexCoordVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getNumTexCoordVBO" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  result = (int)((SoGLVBOElement const *)arg1)->getNumTexCoordVBO();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVBOElement_getTexCoordVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVBOElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoVBO *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVBOElement_getTexCoordVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVBOElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVBOElement_getTexCoordVBO" "', argument " "1"" of type '" "SoGLVBOElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVBOElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLVBOElement_getTexCoordVBO" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoVBO *)((SoGLVBOElement const *)arg1)->getTexCoordVBO(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVBO, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLVBOElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLVBOElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDepthBufferElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoDepthBufferElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDepthBufferElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_initClass", 0, 0, 0)) SWIG_fail;
  SoDepthBufferElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  SoDepthBufferElement::DepthWriteFunction arg4 ;
  SbVec2f arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_set", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoDepthBufferElement_set" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoDepthBufferElement_set" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoDepthBufferElement_set" "', argument " "4"" of type '" "SoDepthBufferElement::DepthWriteFunction""'");
  } 
  arg4 = static_cast< SoDepthBufferElement::DepthWriteFunction >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2f,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDepthBufferElement_set" "', argument " "5"" of type '" "SbVec2f""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDepthBufferElement_set" "', argument " "5"" of type '" "SbVec2f""'");
    } else {
      SbVec2f * temp = reinterpret_cast< SbVec2f * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  SoDepthBufferElement::set(arg1,arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  SbBool *arg3 = 0 ;
  SoDepthBufferElement::DepthWriteFunction *arg4 = 0 ;
  SbVec2f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_get", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBufferElement_get" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDepthBufferElement_get" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDepthBufferElement_get" "', argument " "3"" of type '" "SbBool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDepthBufferElement_get" "', argument " "3"" of type '" "SbBool &""'"); 
  }
  arg3 = reinterpret_cast< SbBool * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoDepthBufferElement__DepthWriteFunction,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoDepthBufferElement_get" "', argument " "4"" of type '" "SoDepthBufferElement::DepthWriteFunction &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDepthBufferElement_get" "', argument " "4"" of type '" "SoDepthBufferElement::DepthWriteFunction &""'"); 
  }
  arg4 = reinterpret_cast< SoDepthBufferElement::DepthWriteFunction * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoDepthBufferElement_get" "', argument " "5"" of type '" "SbVec2f &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoDepthBufferElement_get" "', argument " "5"" of type '" "SbVec2f &""'"); 
  }
  arg5 = reinterpret_cast< SbVec2f * >(argp5);
  SoDepthBufferElement::get(arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getTestEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_getTestEnable" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoDepthBufferElement::getTestEnable(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getWriteEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_getWriteEnable" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SbBool)SoDepthBufferElement::getWriteEnable(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDepthBufferElement::DepthWriteFunction result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_getFunction" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoDepthBufferElement::DepthWriteFunction)SoDepthBufferElement::getFunction(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_getRange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_getRange" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = SoDepthBufferElement::getRange(arg1);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_init" "', argument " "1"" of type '" "SoDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBufferElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_push" "', argument " "1"" of type '" "SoDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBufferElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_pop" "', argument " "1"" of type '" "SoDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBufferElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDepthBufferElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBufferElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBufferElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_matches" "', argument " "1"" of type '" "SoDepthBufferElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBufferElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoDepthBufferElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBufferElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBufferElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBufferElement_copyMatchInfo" "', argument " "1"" of type '" "SoDepthBufferElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBufferElement * >(argp1);
  result = (SoElement *)((SoDepthBufferElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDepthBufferElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDepthBufferElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLDepthBufferElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLDepthBufferElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLDepthBufferElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLDepthBufferElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDepthBufferElement_init" "', argument " "1"" of type '" "SoGLDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDepthBufferElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDepthBufferElement_push" "', argument " "1"" of type '" "SoGLDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDepthBufferElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLDepthBufferElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLDepthBufferElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLDepthBufferElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLDepthBufferElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLDepthBufferElement_pop" "', argument " "1"" of type '" "SoGLDepthBufferElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLDepthBufferElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLDepthBufferElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLDepthBufferElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLDepthBufferElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLDepthBufferElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexAttributeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoVertexAttributeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVertexAttributeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexAttributeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_init" "', argument " "1"" of type '" "SoVertexAttributeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_push" "', argument " "1"" of type '" "SoVertexAttributeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoVertexAttributeData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_add" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVertexAttributeData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeElement_add" "', argument " "2"" of type '" "SoVertexAttributeData *""'"); 
  }
  arg2 = reinterpret_cast< SoVertexAttributeData * >(argp2);
  SoVertexAttributeElement::add(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVertexAttributeElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoVertexAttributeElement *)SoVertexAttributeElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVertexAttributeElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_getNumAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_getNumAttributes" "', argument " "1"" of type '" "SoVertexAttributeElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeElement * >(argp1);
  result = (unsigned int)((SoVertexAttributeElement const *)arg1)->getNumAttributes();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeElement_applyToAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeElement *arg1 = 0 ;
  SoVertexAttributeElement::AttributeApplyFunc *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeElement_applyToAttributes", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeElement_applyToAttributes" "', argument " "1"" of type '" "SoVertexAttributeElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeElement * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVertexAttributeElement_applyToAttributes" "', argument " "2"" of type '" "SoVertexAttributeElement::AttributeApplyFunc *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVertexAttributeElement_applyToAttributes" "', argument " "3"" of type '" "void *""'"); 
  }
  ((SoVertexAttributeElement const *)arg1)->applyToAttributes(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexAttributeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexAttributeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLVertexAttributeElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoGLVertexAttributeElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGLVertexAttributeElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_initClass", 0, 0, 0)) SWIG_fail;
  SoGLVertexAttributeElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVertexAttributeElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVertexAttributeElement_init" "', argument " "1"" of type '" "SoGLVertexAttributeElement *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVertexAttributeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVertexAttributeElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_enableVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVertexAttributeElement *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_enableVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVertexAttributeElement_enableVBO" "', argument " "1"" of type '" "SoGLVertexAttributeElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVertexAttributeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVertexAttributeElement_enableVBO" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ((SoGLVertexAttributeElement const *)arg1)->enableVBO(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_disableVBO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVertexAttributeElement *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_disableVBO", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVertexAttributeElement_disableVBO" "', argument " "1"" of type '" "SoGLVertexAttributeElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVertexAttributeElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLVertexAttributeElement_disableVBO" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ((SoGLVertexAttributeElement const *)arg1)->disableVBO(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_send(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLVertexAttributeElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLVertexAttributeElement_send", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLVertexAttributeElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVertexAttributeElement_send" "', argument " "1"" of type '" "SoGLVertexAttributeElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLVertexAttributeElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLVertexAttributeElement_send" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ((SoGLVertexAttributeElement const *)arg1)->send(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLVertexAttributeElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLVertexAttributeElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLVertexAttributeElement_getInstance" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoGLVertexAttributeElement *)SoGLVertexAttributeElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLVertexAttributeElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLVertexAttributeElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLVertexAttributeElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexAttributeBindingElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoVertexAttributeBindingElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVertexAttributeBindingElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexAttributeBindingElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBindingElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBindingElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBindingElement_init" "', argument " "1"" of type '" "SoVertexAttributeBindingElement *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBindingElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBindingElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoVertexAttributeBindingElement::Binding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBindingElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVertexAttributeBindingElement_set" "', argument " "3"" of type '" "SoVertexAttributeBindingElement::Binding""'");
  } 
  arg3 = static_cast< SoVertexAttributeBindingElement::Binding >(val3);
  SoVertexAttributeBindingElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoVertexAttributeBindingElement::Binding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBindingElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVertexAttributeBindingElement_set" "', argument " "2"" of type '" "SoVertexAttributeBindingElement::Binding""'");
  } 
  arg2 = static_cast< SoVertexAttributeBindingElement::Binding >(val2);
  SoVertexAttributeBindingElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVertexAttributeBindingElement_set__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoVertexAttributeBindingElement_set__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVertexAttributeBindingElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVertexAttributeBindingElement::set(SoState *const,SoNode *const,SoVertexAttributeBindingElement::Binding const)\n"
    "    SoVertexAttributeBindingElement::set(SoState *const,SoVertexAttributeBindingElement::Binding const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoVertexAttributeBindingElement::Binding result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBindingElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoVertexAttributeBindingElement::Binding)SoVertexAttributeBindingElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBindingElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBindingElement::Binding result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBindingElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoVertexAttributeBindingElement::Binding)SoVertexAttributeBindingElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexAttributeBindingElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexAttributeBindingElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoSpecularColorElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSpecularColorElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoSpecularColorElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSpecularColorElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_initClass", 0, 0, 0)) SWIG_fail;
  SoSpecularColorElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpecularColorElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpecularColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_init" "', argument " "1"" of type '" "SoSpecularColorElement *""'"); 
  }
  arg1 = reinterpret_cast< SoSpecularColorElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpecularColorElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbColor *arg4 = (SbColor *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpecularColorElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSpecularColorElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSpecularColorElement_set" "', argument " "4"" of type '" "SbColor const *const""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  SoSpecularColorElement::set(arg1,arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSpecularColorElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoSpecularColorElement *)SoSpecularColorElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSpecularColorElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpecularColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpecularColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_getNum" "', argument " "1"" of type '" "SoSpecularColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpecularColorElement * >(argp1);
  result = (int32_t)((SoSpecularColorElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpecularColorElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpecularColorElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpecularColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_get" "', argument " "1"" of type '" "SoSpecularColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpecularColorElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSpecularColorElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &((SoSpecularColorElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpecularColorElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpecularColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpecularColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpecularColorElement_getArrayPtr" "', argument " "1"" of type '" "SoSpecularColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpecularColorElement * >(argp1);
  result = (SbColor *)((SoSpecularColorElement const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSpecularColorElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSpecularColorElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEmissiveColorElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoEmissiveColorElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoEmissiveColorElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_initClass", 0, 0, 0)) SWIG_fail;
  SoEmissiveColorElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEmissiveColorElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEmissiveColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_init" "', argument " "1"" of type '" "SoEmissiveColorElement *""'"); 
  }
  arg1 = reinterpret_cast< SoEmissiveColorElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEmissiveColorElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  SbColor *arg4 = (SbColor *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEmissiveColorElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEmissiveColorElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEmissiveColorElement_set" "', argument " "4"" of type '" "SbColor const *const""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  SoEmissiveColorElement::set(arg1,arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEmissiveColorElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoEmissiveColorElement *)SoEmissiveColorElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEmissiveColorElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEmissiveColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEmissiveColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_getNum" "', argument " "1"" of type '" "SoEmissiveColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoEmissiveColorElement * >(argp1);
  result = (int32_t)((SoEmissiveColorElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEmissiveColorElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEmissiveColorElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEmissiveColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_get" "', argument " "1"" of type '" "SoEmissiveColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoEmissiveColorElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEmissiveColorElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &((SoEmissiveColorElement const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEmissiveColorElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEmissiveColorElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEmissiveColorElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEmissiveColorElement_getArrayPtr" "', argument " "1"" of type '" "SoEmissiveColorElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoEmissiveColorElement * >(argp1);
  result = (SbColor *)((SoEmissiveColorElement const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEmissiveColorElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEmissiveColorElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoShininessElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShininessElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoShininessElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoShininessElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_initClass", 0, 0, 0)) SWIG_fail;
  SoShininessElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShininessElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShininessElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_init" "', argument " "1"" of type '" "SoShininessElement *""'"); 
  }
  arg1 = reinterpret_cast< SoShininessElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShininessElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  float *arg4 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShininessElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoShininessElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoShininessElement_set" "', argument " "4"" of type '" "float const *const""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  SoShininessElement::set(arg1,arg2,arg3,(float const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShininessElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoShininessElement *)SoShininessElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShininessElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShininessElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShininessElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_getNum" "', argument " "1"" of type '" "SoShininessElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShininessElement * >(argp1);
  result = (int32_t)((SoShininessElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShininessElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShininessElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShininessElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_get" "', argument " "1"" of type '" "SoShininessElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShininessElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoShininessElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)((SoShininessElement const *)arg1)->get(arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShininessElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShininessElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShininessElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShininessElement_getArrayPtr" "', argument " "1"" of type '" "SoShininessElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoShininessElement * >(argp1);
  result = (float *)((SoShininessElement const *)arg1)->getArrayPtr();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShininessElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShininessElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTransparencyElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransparencyElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTransparencyElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTransparencyElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTransparencyElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_init" "', argument " "1"" of type '" "SoTransparencyElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int32_t arg3 ;
  float *arg4 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTransparencyElement_set" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTransparencyElement_set" "', argument " "4"" of type '" "float const *const""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  SoTransparencyElement::set(arg1,arg2,arg3,(float const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTransparencyElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoTransparencyElement *)SoTransparencyElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransparencyElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_getNum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_getNum" "', argument " "1"" of type '" "SoTransparencyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyElement * >(argp1);
  result = (int32_t)((SoTransparencyElement const *)arg1)->getNum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyElement *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyElement_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_get" "', argument " "1"" of type '" "SoTransparencyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTransparencyElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)((SoTransparencyElement const *)arg1)->get(arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyElement_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyElement_getArrayPtr" "', argument " "1"" of type '" "SoTransparencyElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyElement * >(argp1);
  result = (float *)((SoTransparencyElement const *)arg1)->getArrayPtr();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransparencyElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransparencyElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLightModelElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLightModelElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoLightModelElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoLightModelElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_initClass", 0, 0, 0)) SWIG_fail;
  SoLightModelElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModelElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightModelElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModelElement_init" "', argument " "1"" of type '" "SoLightModelElement *""'"); 
  }
  arg1 = reinterpret_cast< SoLightModelElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModelElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoLightModelElement::Model arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModelElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoLightModelElement_set" "', argument " "2"" of type '" "SoLightModelElement::Model""'");
  } 
  arg2 = static_cast< SoLightModelElement::Model >(val2);
  SoLightModelElement::set(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SoLightModelElement::Model arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModelElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLightModelElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoLightModelElement_set" "', argument " "3"" of type '" "SoLightModelElement::Model""'");
  } 
  arg3 = static_cast< SoLightModelElement::Model >(val3);
  SoLightModelElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoLightModelElement_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoLightModelElement_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoLightModelElement_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoLightModelElement_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLightModelElement::set(SoState *const,SoLightModelElement::Model const)\n"
    "    SoLightModelElement::set(SoState *const,SoNode *const,SoLightModelElement::Model const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoLightModelElement::Model result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModelElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoLightModelElement::Model)SoLightModelElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_getDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightModelElement::Model result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightModelElement_getDefault", 0, 0, 0)) SWIG_fail;
  result = (SoLightModelElement::Model)SoLightModelElement::getDefault();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightModelElement_getInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoLightModelElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightModelElement_getInstance" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (SoLightModelElement *)SoLightModelElement::getInstance(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLightModelElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightModelElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightModelElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbColor4f *)new SbColor4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbColor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbColor const &""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbColor4f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbColor4f *)new SbColor4f((SbColor const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbColor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbColor const &""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  result = (SbColor4f *)new SbColor4f((SbColor const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbColor4f" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (SbColor4f *)new SbColor4f((SbVec4f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float *arg1 = (float *)0 ;
  float temp1[4] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec4f_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbColor4f *)new SbColor4f((float const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbColor4f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbColor4f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbColor4f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbColor4f" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbColor4f *)new SbColor4f(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbColor4f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbColor4f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbColor4f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbColor4f *)new SbColor4f(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbColor4f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbColor4f", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbColor4f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbColor4f__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbColor4f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbColor4f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbColor4f__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbColor4f__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbColor4f__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbColor4f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor4f::SbColor4f()\n"
    "    SbColor4f::SbColor4f(SbColor const &,float const)\n"
    "    SbColor4f::SbColor4f(SbColor const &)\n"
    "    SbColor4f::SbColor4f(SbVec4f const &)\n"
    "    SbColor4f::SbColor4f(float const *const)\n"
    "    SbColor4f::SbColor4f(float const,float const,float const,float const)\n"
    "    SbColor4f::SbColor4f(float const,float const,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor4f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbColor4f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbColor4f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor4f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbColor4f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbColor4f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbColor4f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbColor4f_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbColor4f_setValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbColor4f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor4f::setValue(float const,float const,float const,float const)\n"
    "    SbColor4f::setValue(float const,float const,float const)\n"
    "    SbColor4f::setValue(float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor4f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  float temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_getValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  (arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setRGB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f_setRGB", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setRGB" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f_setRGB" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f_setRGB" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = (SbColor4f *) &(arg1)->setRGB((SbColor const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_getRGB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f_getRGB", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_getRGB" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f_getRGB" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f_getRGB" "', argument " "2"" of type '" "SbColor &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->getRGB(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setHSVValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor4f_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbColor4f_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbColor4f_setHSVValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = (SbColor4f *) &(arg1)->setHSVValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setHSVValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor4f_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbColor4f_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbColor4f *) &(arg1)->setHSVValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setHSVValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  float val3 ;
  int ecode3 = 0 ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setHSVValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbColor4f_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (SbColor4f *) &(arg1)->setHSVValue((float const (*))arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setHSVValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setHSVValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbColor4f *) &(arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbColor4f_setHSVValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbColor4f_setHSVValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbColor4f_setHSVValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbColor4f_setHSVValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbColor4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbColor4f_setHSVValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbColor4f_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbColor4f::setHSVValue(float,float,float,float)\n"
    "    SbColor4f::setHSVValue(float,float,float)\n"
    "    SbColor4f::setHSVValue(float const [3],float)\n"
    "    SbColor4f::setHSVValue(float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbColor4f_getHSVValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_getHSVValue" "', argument " "1"" of type '" "SbColor4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ((SbColor4f const *)arg1)->getHSVValue(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_setPackedValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f_setPackedValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_setPackedValue" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f_setPackedValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (SbColor4f *) &(arg1)->setPackedValue(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f_getPackedValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f_getPackedValue" "', argument " "1"" of type '" "SbColor4f const *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  result = (uint32_t)((SbColor4f const *)arg1)->getPackedValue();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___imul__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___imul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbColor4f *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___itruediv__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___itruediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbColor4f *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___iadd__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___iadd__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___iadd__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = (SbColor4f *) &(arg1)->operator +=((SbColor4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___isub__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___isub__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___isub__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = (SbColor4f *) &(arg1)->operator -=((SbColor4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___add__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___add__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___add__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = SbColor4f___add__(arg1,(SbColor4f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___sub__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___sub__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___sub__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = SbColor4f___sub__(arg1,(SbColor4f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___mul__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor4f___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___rmul__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor4f___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___div__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbColor4f___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___eq__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___eq__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___eq__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = (int)SbColor4f___eq__(arg1,(SbColor4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbColor4f___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___nq__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbColor4f___nq__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbColor4f___nq__" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = (int)SbColor4f___nq__(arg1,(SbColor4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbColor4f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbColor4f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbColor4f___getitem__" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbColor4f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SbColor4f___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbColor4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbColor4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbColor4f" "', argument " "1"" of type '" "SbColor4f *""'"); 
  }
  arg1 = reinterpret_cast< SbColor4f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbColor4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbColor4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbColor4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCombineElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCombineElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextureCombineElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextureCombineElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCombineElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombineElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombineElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_init" "', argument " "1"" of type '" "SoTextureCombineElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombineElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombineElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  SoTextureCombineElement::Operation arg4 ;
  SoTextureCombineElement::Operation arg5 ;
  SoTextureCombineElement::Source *arg6 = 0 ;
  SoTextureCombineElement::Source *arg7 = 0 ;
  SoTextureCombineElement::Operand *arg8 = 0 ;
  SoTextureCombineElement::Operand *arg9 = 0 ;
  SbColor4f *arg10 = 0 ;
  float arg11 ;
  float arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_set", 12, 12, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombineElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextureCombineElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoTextureCombineElement_set" "', argument " "4"" of type '" "SoTextureCombineElement::Operation""'");
  } 
  arg4 = static_cast< SoTextureCombineElement::Operation >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoTextureCombineElement_set" "', argument " "5"" of type '" "SoTextureCombineElement::Operation""'");
  } 
  arg5 = static_cast< SoTextureCombineElement::Operation >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoTextureCombineElement_set" "', argument " "6"" of type '" "SoTextureCombineElement::Source const *""'"); 
  }
  arg6 = reinterpret_cast< SoTextureCombineElement::Source * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoTextureCombineElement_set" "', argument " "7"" of type '" "SoTextureCombineElement::Source const *""'"); 
  }
  arg7 = reinterpret_cast< SoTextureCombineElement::Source * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoTextureCombineElement_set" "', argument " "8"" of type '" "SoTextureCombineElement::Operand const *""'"); 
  }
  arg8 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoTextureCombineElement_set" "', argument " "9"" of type '" "SoTextureCombineElement::Operand const *""'"); 
  }
  arg9 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoTextureCombineElement_set" "', argument " "10"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_set" "', argument " "10"" of type '" "SbColor4f const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor4f * >(argp10);
  ecode11 = SWIG_AsVal_float(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoTextureCombineElement_set" "', argument " "11"" of type '" "float""'");
  } 
  arg11 = static_cast< float >(val11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoTextureCombineElement_set" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  SoTextureCombineElement::set(arg1,arg2,arg3,arg4,arg5,(enum SoTextureCombineElement::Source const *)arg6,(enum SoTextureCombineElement::Source const *)arg7,(enum SoTextureCombineElement::Operand const *)arg8,(enum SoTextureCombineElement::Operand const *)arg9,(SbColor4f const &)*arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_isDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_isDefault", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_isDefault" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCombineElement_isDefault" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoTextureCombineElement::isDefault(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  int arg2 ;
  SoTextureCombineElement::Operation *arg3 = 0 ;
  SoTextureCombineElement::Operation *arg4 = 0 ;
  SoTextureCombineElement::Source *arg5 = 0 ;
  SoTextureCombineElement::Source *arg6 = 0 ;
  SoTextureCombineElement::Operand *arg7 = 0 ;
  SoTextureCombineElement::Operand *arg8 = 0 ;
  SbColor4f *arg9 = 0 ;
  float *arg10 = 0 ;
  float *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject *swig_obj[11] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_get", 11, 11, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_get" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCombineElement_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoTextureCombineElement__Operation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextureCombineElement_get" "', argument " "3"" of type '" "SoTextureCombineElement::Operation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_get" "', argument " "3"" of type '" "SoTextureCombineElement::Operation &""'"); 
  }
  arg3 = reinterpret_cast< SoTextureCombineElement::Operation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SoTextureCombineElement__Operation,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTextureCombineElement_get" "', argument " "4"" of type '" "SoTextureCombineElement::Operation &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_get" "', argument " "4"" of type '" "SoTextureCombineElement::Operation &""'"); 
  }
  arg4 = reinterpret_cast< SoTextureCombineElement::Operation * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoTextureCombineElement_get" "', argument " "5"" of type '" "SoTextureCombineElement::Source *""'"); 
  }
  arg5 = reinterpret_cast< SoTextureCombineElement::Source * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoTextureCombineElement_get" "', argument " "6"" of type '" "SoTextureCombineElement::Source *""'"); 
  }
  arg6 = reinterpret_cast< SoTextureCombineElement::Source * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoTextureCombineElement_get" "', argument " "7"" of type '" "SoTextureCombineElement::Operand *""'"); 
  }
  arg7 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoTextureCombineElement_get" "', argument " "8"" of type '" "SoTextureCombineElement::Operand *""'"); 
  }
  arg8 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_SbColor4f,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoTextureCombineElement_get" "', argument " "9"" of type '" "SbColor4f &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_get" "', argument " "9"" of type '" "SbColor4f &""'"); 
  }
  arg9 = reinterpret_cast< SbColor4f * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoTextureCombineElement_get" "', argument " "10"" of type '" "float &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_get" "', argument " "10"" of type '" "float &""'"); 
  }
  arg10 = reinterpret_cast< float * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SoTextureCombineElement_get" "', argument " "11"" of type '" "float &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_get" "', argument " "11"" of type '" "float &""'"); 
  }
  arg11 = reinterpret_cast< float * >(argp11);
  SoTextureCombineElement::get(arg1,arg2,*arg3,*arg4,arg5,arg6,arg7,arg8,*arg9,*arg10,*arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombineElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombineElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_push" "', argument " "1"" of type '" "SoTextureCombineElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombineElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombineElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombineElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombineElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_matches" "', argument " "1"" of type '" "SoTextureCombineElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombineElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombineElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoTextureCombineElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombineElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombineElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_copyMatchInfo" "', argument " "1"" of type '" "SoTextureCombineElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombineElement * >(argp1);
  result = (SoElement *)((SoTextureCombineElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_setElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombineElement *arg1 = 0 ;
  int arg2 ;
  SbUniqueId arg3 ;
  SoTextureCombineElement::Operation arg4 ;
  SoTextureCombineElement::Operation arg5 ;
  SoTextureCombineElement::Source *arg6 = 0 ;
  SoTextureCombineElement::Source *arg7 = 0 ;
  SoTextureCombineElement::Operand *arg8 = 0 ;
  SoTextureCombineElement::Operand *arg9 = 0 ;
  SbColor4f *arg10 = 0 ;
  float arg11 ;
  float arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_setElt", 12, 12, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombineElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_setElt" "', argument " "1"" of type '" "SoTextureCombineElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombineElement * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCombineElement_setElt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextureCombineElement_setElt" "', argument " "3"" of type '" "SbUniqueId""'");
  } 
  arg3 = static_cast< SbUniqueId >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoTextureCombineElement_setElt" "', argument " "4"" of type '" "SoTextureCombineElement::Operation""'");
  } 
  arg4 = static_cast< SoTextureCombineElement::Operation >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoTextureCombineElement_setElt" "', argument " "5"" of type '" "SoTextureCombineElement::Operation""'");
  } 
  arg5 = static_cast< SoTextureCombineElement::Operation >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoTextureCombineElement_setElt" "', argument " "6"" of type '" "SoTextureCombineElement::Source const *""'"); 
  }
  arg6 = reinterpret_cast< SoTextureCombineElement::Source * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SoTextureCombineElement__Source, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoTextureCombineElement_setElt" "', argument " "7"" of type '" "SoTextureCombineElement::Source const *""'"); 
  }
  arg7 = reinterpret_cast< SoTextureCombineElement::Source * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoTextureCombineElement_setElt" "', argument " "8"" of type '" "SoTextureCombineElement::Operand const *""'"); 
  }
  arg8 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_SoTextureCombineElement__Operand, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoTextureCombineElement_setElt" "', argument " "9"" of type '" "SoTextureCombineElement::Operand const *""'"); 
  }
  arg9 = reinterpret_cast< SoTextureCombineElement::Operand * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoTextureCombineElement_setElt" "', argument " "10"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCombineElement_setElt" "', argument " "10"" of type '" "SbColor4f const &""'"); 
  }
  arg10 = reinterpret_cast< SbColor4f * >(argp10);
  ecode11 = SWIG_AsVal_float(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoTextureCombineElement_setElt" "', argument " "11"" of type '" "float""'");
  } 
  arg11 = static_cast< float >(val11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoTextureCombineElement_setElt" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  (arg1)->setElt(arg2,arg3,arg4,arg5,(SoTextureCombineElement::Source const *)arg6,(SoTextureCombineElement::Source const *)arg7,(SoTextureCombineElement::Operand const *)arg8,(SoTextureCombineElement::Operand const *)arg9,(SbColor4f const &)*arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombineElement_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombineElement_apply", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombineElement_apply" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTextureCombineElement_apply" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  SoTextureCombineElement::apply(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCombineElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCombineElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoTextureUnitElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureUnitElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoTextureUnitElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTextureUnitElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureUnitElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnitElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnitElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnitElement_init" "', argument " "1"" of type '" "SoTextureUnitElement *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnitElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnitElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = (SoState *)0 ;
  SoNode *arg2 = (SoNode *)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnitElement_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnitElement_set" "', argument " "1"" of type '" "SoState *const""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnitElement_set" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTextureUnitElement_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoTextureUnitElement::set(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnitElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnitElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  result = (int)SoTextureUnitElement::get(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureUnitElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureUnitElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoEngine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_initClass", 0, 0, 0)) SWIG_fail;
  SoEngine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_initClasses", 0, 0, 0)) SWIG_fail;
  SoEngine::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEngine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_evaluateWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_evaluateWrapper" "', argument " "1"" of type '" "SoEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  (arg1)->evaluateWrapper();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getOutputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  SoEngineOutputList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_getOutputs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_getOutputs" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoEngineOutputList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngine_getOutputs" "', argument " "2"" of type '" "SoEngineOutputList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEngine_getOutputs" "', argument " "2"" of type '" "SoEngineOutputList &""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutputList * >(argp2);
  result = (int)((SoEngine const *)arg1)->getOutputs(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_getOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_getOutput" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoEngineOutput *)((SoEngine const *)arg1)->getOutput((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getOutputName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_getOutputName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_getOutputName" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngine_getOutputName" "', argument " "2"" of type '" "SoEngineOutput const *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)((SoEngine const *)arg1)->getOutputName((SoEngineOutput const *)arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_getOutputData" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = (SoEngineOutputData *)((SoEngine const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getByName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoEngine *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SoEngine *)SoEngine::getByName((SbName const &)*arg1);
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getByName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  SoEngineList *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoEngineList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngine_getByName" "', argument " "2"" of type '" "SoEngineList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEngine_getByName" "', argument " "2"" of type '" "SoEngineList &""'"); 
  }
  arg2 = reinterpret_cast< SoEngineList * >(argp2);
  result = (int)SoEngine::getByName((SbName const &)*arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_getByName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEngine_getByName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) && 
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_SoEngine_getByName__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      _v = 1;
      
      
      
      
      if (!PyBytes_Check(argv[0]) && 
        !PyUnicode_Check(argv[0]) && 
        (SWIG_ConvertPtr(argv[0], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
      
      {
        _v = 0;
      }
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngineList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoEngine_getByName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEngine_getByName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngine::getByName(SbName const &)\n"
    "    SoEngine::getByName(SbName const &,SoEngineList &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEngine_isNotifying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_isNotifying" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = (SbBool)((SoEngine const *)arg1)->isNotifying();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_notify" "', argument " "1"" of type '" "SoEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngine_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_copy" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = (SoEngine *)((SoEngine const *)arg1)->copy();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_copyThroughConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_copyThroughConnection" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = (SoFieldContainer *)((SoEngine const *)arg1)->copyThroughConnection();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_shouldCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_shouldCopy" "', argument " "1"" of type '" "SoEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  result = (SbBool)((SoEngine const *)arg1)->shouldCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngine_writeInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngine *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngine_writeInstance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngine_writeInstance" "', argument " "1"" of type '" "SoEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngine_writeInstance" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->writeInstance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEngine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoEngineOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoEngineOutput", 0, 0, 0)) SWIG_fail;
  result = (SoEngineOutput *)new SoEngineOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoEngineOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEngineOutput" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getConnectionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getConnectionType" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = ((SoEngineOutput const *)arg1)->getConnectionType();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getForwardConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_getForwardConnections", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getForwardConnections" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEngineOutput_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoEngineOutput const *)arg1)->getForwardConnections(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_enable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_enable" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutput_enable" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->enable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_isEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_isEnabled" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (SbBool)((SoEngineOutput const *)arg1)->isEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getContainer" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (SoEngine *)((SoEngineOutput const *)arg1)->getContainer();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getNodeContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodeEngine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getNodeContainer" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (SoNodeEngine *)((SoEngineOutput const *)arg1)->getNodeContainer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_isNodeEngineOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_isNodeEngineOutput" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (SbBool)((SoEngineOutput const *)arg1)->isNodeEngineOutput();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_setContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_setContainer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_setContainer" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_setContainer" "', argument " "2"" of type '" "SoEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  (arg1)->setContainer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_setNodeContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoNodeEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_setNodeContainer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_setNodeContainer" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_setNodeContainer" "', argument " "2"" of type '" "SoNodeEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeEngine * >(argp2);
  (arg1)->setNodeContainer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_addConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_addConnection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_addConnection" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_addConnection" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->addConnection(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_removeConnection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_removeConnection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_removeConnection" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_removeConnection" "', argument " "2"" of type '" "SoField *""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->removeConnection(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getNumConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getNumConnections" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (int)((SoEngineOutput const *)arg1)->getNumConnections();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_prepareToWrite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_prepareToWrite" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  ((SoEngineOutput const *)arg1)->prepareToWrite();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_doneWriting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_doneWriting" "', argument " "1"" of type '" "SoEngineOutput const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  ((SoEngineOutput const *)arg1)->doneWriting();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_touchSlaves(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutput_touchSlaves", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_touchSlaves" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutput_touchSlaves" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEngineOutput_touchSlaves" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->touchSlaves(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutput_getFieldContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldContainer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutput_getFieldContainer" "', argument " "1"" of type '" "SoEngineOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutput * >(argp1);
  result = (SoFieldContainer *)(arg1)->getFieldContainer();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEngineOutput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEngineOutput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEngineOutput_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoEngineOutputData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoEngineOutputData *)new SoEngineOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoEngineOutputData" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  result = (SoEngineOutputData *)new SoEngineOutputData((SoEngineOutputData const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoEngineOutputData" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoEngineOutputData *)new SoEngineOutputData(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEngineOutputData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoEngineOutputData", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoEngineOutputData__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoEngineOutputData__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoEngineOutputData__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoEngineOutputData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineOutputData::SoEngineOutputData()\n"
    "    SoEngineOutputData::SoEngineOutputData(SoEngineOutputData const *)\n"
    "    SoEngineOutputData::SoEngineOutputData(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoEngineOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEngineOutputData" "', argument " "1"" of type '" "SoEngineOutputData *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_addOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  char *arg3 = 0 ;
  SoEngineOutput *arg4 = 0 ;
  SoType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_addOutput" "', argument " "1"" of type '" "SoEngineOutputData *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_addOutput" "', argument " "2"" of type '" "SoEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_addOutput" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEngineOutputData_addOutput" "', argument " "4"" of type '" "SoEngineOutput const *""'"); 
  }
  arg4 = reinterpret_cast< SoEngineOutput * >(argp4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEngineOutputData_addOutput" "', argument " "5"" of type '" "SoType""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEngineOutputData_addOutput" "', argument " "5"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  (arg1)->addOutput((SoEngine const *)arg2,(char const *)arg3,(SoEngineOutput const *)arg4,SWIG_STD_MOVE(arg5));
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_addOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoNodeEngine *arg2 = 0 ;
  char *arg3 = 0 ;
  SoEngineOutput *arg4 = 0 ;
  SoType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_addOutput" "', argument " "1"" of type '" "SoEngineOutputData *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_addOutput" "', argument " "2"" of type '" "SoNodeEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeEngine * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_addOutput" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEngineOutputData_addOutput" "', argument " "4"" of type '" "SoEngineOutput const *""'"); 
  }
  arg4 = reinterpret_cast< SoEngineOutput * >(argp4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoEngineOutputData_addOutput" "', argument " "5"" of type '" "SoType""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEngineOutputData_addOutput" "', argument " "5"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  (arg1)->addOutput((SoNodeEngine const *)arg2,(char const *)arg3,(SoEngineOutput const *)arg4,SWIG_STD_MOVE(arg5));
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_addOutput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEngineOutputData_addOutput", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoEngineOutputData_addOutput__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNodeEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoEngineOutputData_addOutput__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEngineOutputData_addOutput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineOutputData::addOutput(SoEngine const *,char const *,SoEngineOutput const *,SoType)\n"
    "    SoEngineOutputData::addOutput(SoNodeEngine const *,char const *,SoEngineOutput const *,SoType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getNumOutputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getNumOutputs" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  result = (int)((SoEngineOutputData const *)arg1)->getNumOutputs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getOutputName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputData_getOutputName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getOutputName" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputData_getOutputName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbName *) &((SoEngineOutputData const *)arg1)->getOutputName(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getOutput__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getOutput" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_getOutput" "', argument " "2"" of type '" "SoEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEngineOutputData_getOutput" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoEngineOutput *)((SoEngineOutputData const *)arg1)->getOutput((SoEngine const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getOutput__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoNodeEngine *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getOutput" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_getOutput" "', argument " "2"" of type '" "SoNodeEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeEngine * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoEngineOutputData_getOutput" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoEngineOutput *)((SoEngineOutputData const *)arg1)->getOutput((SoNodeEngine const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getOutput(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEngineOutputData_getOutput", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoEngineOutputData_getOutput__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNodeEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoEngineOutputData_getOutput__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEngineOutputData_getOutput'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineOutputData::getOutput(SoEngine const *,int) const\n"
    "    SoEngineOutputData::getOutput(SoNodeEngine const *,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  SoEngineOutput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getIndex" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_getIndex" "', argument " "2"" of type '" "SoEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_getIndex" "', argument " "3"" of type '" "SoEngineOutput const *""'"); 
  }
  arg3 = reinterpret_cast< SoEngineOutput * >(argp3);
  result = (int)((SoEngineOutputData const *)arg1)->getIndex((SoEngine const *)arg2,(SoEngineOutput const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoNodeEngine *arg2 = 0 ;
  SoEngineOutput *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getIndex" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_getIndex" "', argument " "2"" of type '" "SoNodeEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoNodeEngine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_getIndex" "', argument " "3"" of type '" "SoEngineOutput const *""'"); 
  }
  arg3 = reinterpret_cast< SoEngineOutput * >(argp3);
  result = (int)((SoEngineOutputData const *)arg1)->getIndex((SoNodeEngine const *)arg2,(SoEngineOutput const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEngineOutputData_getIndex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoEngineOutputData_getIndex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEngineOutputData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNodeEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoEngineOutput, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoEngineOutputData_getIndex__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEngineOutputData_getIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEngineOutputData::getIndex(SoEngine const *,SoEngineOutput const *) const\n"
    "    SoEngineOutputData::getIndex(SoNodeEngine const *,SoEngineOutput const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoType *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputData_getType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_getType" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEngineOutputData_getType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoType *) &((SoEngineOutputData const *)arg1)->getType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_readDescriptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  SoEngine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputData_readDescriptions", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_readDescriptions" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_readDescriptions" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_readDescriptions" "', argument " "3"" of type '" "SoEngine *""'"); 
  }
  arg3 = reinterpret_cast< SoEngine * >(argp3);
  result = (SbBool)((SoEngineOutputData const *)arg1)->readDescriptions(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEngineOutputData_writeDescriptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEngineOutputData *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SoEngine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEngineOutputData_writeDescriptions", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEngineOutputData_writeDescriptions" "', argument " "1"" of type '" "SoEngineOutputData const *""'"); 
  }
  arg1 = reinterpret_cast< SoEngineOutputData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEngineOutputData_writeDescriptions" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoEngineOutputData_writeDescriptions" "', argument " "3"" of type '" "SoEngine *""'"); 
  }
  arg3 = reinterpret_cast< SoEngine * >(argp3);
  ((SoEngineOutputData const *)arg1)->writeDescriptions(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEngineOutputData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEngineOutputData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEngineOutputData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFBool", 0, 0, 0)) SWIG_fail;
  result = (SoMFBool *)new SoMFBool();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFBool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFBool" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFBool::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFBool::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_getTypeId" "', argument " "1"" of type '" "SoMFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  result = ((SoMFBool const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_copyFrom" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBool_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBool_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_isSame" "', argument " "1"" of type '" "SoMFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBool_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBool_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFBool const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_find" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_find" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFBool_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_find" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_find" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFBool_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFBool_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFBool_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFBool_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFBool::find(SbBool,SbBool)\n"
    "    SoMFBool::find(SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbBool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_setValues" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFBool_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFBool_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbBool const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_set1Value" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFBool_set1Value" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_setValue" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_setValue" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SoMFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool___eq__" "', argument " "1"" of type '" "SoMFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFBool,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBool___eq__" "', argument " "2"" of type '" "SoMFBool const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBool___eq__" "', argument " "2"" of type '" "SoMFBool const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFBool * >(argp2);
  result = (SbBool)((SoMFBool const *)arg1)->operator ==((SoMFBool const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFBool___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SoMFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool___ne__" "', argument " "1"" of type '" "SoMFBool const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFBool,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBool___ne__" "', argument " "2"" of type '" "SoMFBool const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBool___ne__" "', argument " "2"" of type '" "SoMFBool const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFBool * >(argp2);
  result = (SbBool)((SoMFBool const *)arg1)->operator !=((SoMFBool const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFBool_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_startEditing" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  result = (SbBool *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_finishEditing" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  SbBool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_setValuesPointer" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFBool_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(SbBool const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  SbBool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbBool *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_setValuesPointer" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFBool_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFBool_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFBool_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFBool_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFBool_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFBool::setValuesPointer(int const,SbBool const *)\n"
    "    SoMFBool::setValuesPointer(int const,SbBool *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFBool_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool_initClass", 0, 0, 0)) SWIG_fail;
  SoMFBool::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  SoMFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_setValue" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBool_setValue" "', argument " "2"" of type '" "SoMFBool const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFBool * >(argp2);
  SoMFBool_setValue__SWIG_1(arg1,(SoMFBool const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFBool_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFBool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFBool_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFBool_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFBool_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFBool::setValue(SbBool)\n"
    "    SoMFBool::setValue(SoMFBool const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFBool___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool___getitem__" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoMFBool___getitem__(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBool___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool___setitem__" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFBool___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFBool___setitem__" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoMFBool___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbBool *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_getValues" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFBool_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbBool *)SoMFBool___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFBool *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbBool *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBool_getValues" "', argument " "1"" of type '" "SoMFBool *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBool * >(argp1);
  result = (SbBool *)SoMFBool___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBool_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFBool_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFBool_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFBool, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFBool_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFBool_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFBool::__getValuesHelper__(int &,int)\n"
    "    SoMFBool::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFBool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFBool, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFBool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFEnum", 0, 0, 0)) SWIG_fail;
  result = (SoMFEnum *)new SoMFEnum();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFEnum" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFEnum::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFEnum::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_getTypeId" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  result = ((SoMFEnum const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_copyFrom" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEnum_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEnum_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_isSame" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEnum_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEnum_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFEnum const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_find" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_find" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEnum_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_find" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_find" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEnum_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFEnum_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFEnum_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEnum_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEnum::find(int,SbBool)\n"
    "    SoMFEnum::find(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_setValues" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEnum_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (int*)malloc(len*sizeof(int));
      convert_SoMFEnum_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(int const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_set1Value" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEnum_set1Value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_setValue" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_setValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum___eq__" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFEnum,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEnum___eq__" "', argument " "2"" of type '" "SoMFEnum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEnum___eq__" "', argument " "2"" of type '" "SoMFEnum const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  result = (SbBool)((SoMFEnum const *)arg1)->operator ==((SoMFEnum const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFEnum___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum___ne__" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFEnum,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEnum___ne__" "', argument " "2"" of type '" "SoMFEnum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEnum___ne__" "', argument " "2"" of type '" "SoMFEnum const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  result = (SbBool)((SoMFEnum const *)arg1)->operator !=((SoMFEnum const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_startEditing" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  result = (int *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_finishEditing" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_initClass", 0, 0, 0)) SWIG_fail;
  SoMFEnum::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_setValue" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  SbName arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_set1Value" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2])){
      arg3 = SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg3 = *namePtr;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEnum_set1Value", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFEnum_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr = NULL;
          _v = 1;
          
          
          
          
          
          // http://stackoverflow.com/questions/2807887/cs-char-by-swig-got-problem-in-python-3-0
          if (!PyBytes_Check(argv[2]) &&
            !PyUnicode_Check(argv[2]) && 
            (SWIG_ConvertPtr(argv[2], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
          
          {
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_SoMFEnum_set1Value__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEnum_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEnum::set1Value(int const,int)\n"
    "    SoMFEnum::set1Value(int const,SbName const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setEnums(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  int *arg3 = (int *)0 ;
  SbName *arg4 = (SbName *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_setEnums", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_setEnums" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_setEnums" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFEnum_setEnums" "', argument " "3"" of type '" "int const *const""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbName, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFEnum_setEnums" "', argument " "4"" of type '" "SbName const *const""'"); 
  }
  arg4 = reinterpret_cast< SbName * >(argp4);
  (arg1)->setEnums(arg2,(int const *)arg3,(SbName const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getNumEnums(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_getNumEnums" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  result = (int)((SoMFEnum const *)arg1)->getNumEnums();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getEnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum_getEnum", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_getEnum" "', argument " "1"" of type '" "SoMFEnum const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum_getEnum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (int)((SoMFEnum const *)arg1)->getEnum(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum___getitem__" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)SoMFEnum___getitem__(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEnum___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum___setitem__" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEnum___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEnum___setitem__" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  SoMFEnum___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_setValue" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEnum_setValue" "', argument " "2"" of type '" "SoMFEnum const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  SoMFEnum_setValue__SWIG_2(arg1,(SoMFEnum const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEnum_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFEnum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFEnum_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFEnum_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        
        // http://stackoverflow.com/questions/2807887/cs-char-by-swig-got-problem-in-python-3-0
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFEnum_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEnum_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEnum::setValue(int)\n"
    "    SoMFEnum::setValue(SbName const)\n"
    "    SoMFEnum::setValue(SoMFEnum const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_getValues" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEnum_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int *)SoMFEnum___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEnum *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEnum_getValues" "', argument " "1"" of type '" "SoMFEnum *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEnum * >(argp1);
  result = (int *)SoMFEnum___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEnum_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEnum_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFEnum_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEnum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFEnum_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEnum_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEnum::__getValuesHelper__(int &,int)\n"
    "    SoMFEnum::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFEnum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFEnum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFEnum_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBoolOperation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBoolOperation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_getTypeId" "', argument " "1"" of type '" "SoBoolOperation const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = ((SoBoolOperation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_getFieldData" "', argument " "1"" of type '" "SoBoolOperation const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoFieldData *)((SoBoolOperation const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_getOutputData" "', argument " "1"" of type '" "SoBoolOperation const *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoEngineOutputData *)((SoBoolOperation const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoBoolOperation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  SoMFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_a_set" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoolOperation_a_set" "', argument " "2"" of type '" "SoMFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoMFBool * >(argp2);
  if (arg1) (arg1)->a = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_a_get" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoMFBool *)& ((arg1)->a);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  SoMFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_b_set" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoolOperation_b_set" "', argument " "2"" of type '" "SoMFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoMFBool * >(argp2);
  if (arg1) (arg1)->b = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_b_get" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoMFBool *)& ((arg1)->b);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_operation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_operation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_operation_set" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoolOperation_operation_set" "', argument " "2"" of type '" "SoMFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  if (arg1) (arg1)->operation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_operation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_operation_get" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoMFEnum *)& ((arg1)->operation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_output_set" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoolOperation_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_output_get" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_inverse_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_inverse_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_inverse_set" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBoolOperation_inverse_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->inverse = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_inverse_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBoolOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBoolOperation_inverse_get" "', argument " "1"" of type '" "SoBoolOperation *""'"); 
  }
  arg1 = reinterpret_cast< SoBoolOperation * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->inverse);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBoolOperation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBoolOperation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBoolOperation", 0, 0, 0)) SWIG_fail;
  result = (SoBoolOperation *)new SoBoolOperation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBoolOperation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBoolOperation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBoolOperation_initClass", 0, 0, 0)) SWIG_fail;
  SoBoolOperation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBoolOperation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBoolOperation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBoolOperation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFFloat", 0, 0, 0)) SWIG_fail;
  result = (SoMFFloat *)new SoMFFloat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFFloat" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFFloat::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFFloat::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_getTypeId" "', argument " "1"" of type '" "SoMFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  result = ((SoMFFloat const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_copyFrom" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFFloat_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFFloat_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_isSame" "', argument " "1"" of type '" "SoMFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFFloat_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFFloat_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFFloat const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  float arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_find" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_find" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFFloat_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_find" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_find" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFFloat_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFFloat_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFFloat_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFFloat_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFFloat::find(float,SbBool)\n"
    "    SoMFFloat::find(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_setValues" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFFloat_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[3], len, temp4);
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(float const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_set1Value" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFFloat_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_setValue" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat___eq__" "', argument " "1"" of type '" "SoMFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFFloat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFFloat___eq__" "', argument " "2"" of type '" "SoMFFloat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFFloat___eq__" "', argument " "2"" of type '" "SoMFFloat const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  result = (SbBool)((SoMFFloat const *)arg1)->operator ==((SoMFFloat const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFFloat___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat___ne__" "', argument " "1"" of type '" "SoMFFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFFloat,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFFloat___ne__" "', argument " "2"" of type '" "SoMFFloat const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFFloat___ne__" "', argument " "2"" of type '" "SoMFFloat const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  result = (SbBool)((SoMFFloat const *)arg1)->operator !=((SoMFFloat const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_startEditing" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  result = (float *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_finishEditing" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_setValuesPointer" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_setValuesPointer" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFFloat_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFFloat_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFFloat_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFFloat_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFFloat::setValuesPointer(int const,float const *)\n"
    "    SoMFFloat::setValuesPointer(int const,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat_initClass", 0, 0, 0)) SWIG_fail;
  SoMFFloat::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat___getitem__" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (float)SoMFFloat___getitem__(arg1,arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFFloat___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat___setitem__" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFFloat___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFFloat___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoMFFloat___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_setValue" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFFloat_setValue" "', argument " "2"" of type '" "SoMFFloat const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  SoMFFloat_setValue__SWIG_1(arg1,(SoMFFloat const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFFloat_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFFloat, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFFloat_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFFloat_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFFloat_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFFloat::setValue(float)\n"
    "    SoMFFloat::setValue(SoMFFloat const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  float *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_getValues" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFFloat_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (float *)SoMFFloat___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyFloat_FromDouble((double)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFFloat *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  float *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFFloat_getValues" "', argument " "1"" of type '" "SoMFFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoMFFloat * >(argp1);
  result = (float *)SoMFFloat___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyFloat_FromDouble((double)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFFloat_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFFloat_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFFloat_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFFloat, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFFloat_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFFloat_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFFloat::__getValuesHelper__(int &,int)\n"
    "    SoMFFloat::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFFloat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFFloat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFFloat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec3f *)new SoMFVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec3f" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_getTypeId" "', argument " "1"" of type '" "SoMFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  result = ((SoMFVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_copyFrom" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_isSame" "', argument " "1"" of type '" "SoMFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec3f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_find" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_find" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_find" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_find" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_find" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_find" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (int)(arg1)->find((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3f_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec3f_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::find(SbVec3f const &,SbBool)\n"
    "    SoMFVec3f::find(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValues" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbVec3f[len];
        for (int i = 0; i < len; i++) {
          SbVec3f * VecPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &VecPtr, SWIGTYPE_p_SbVec3f, 1);
          if (VecPtr != NULL) {
            arg4[i] = *VecPtr; 
          }
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbVec3f const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_set1Value" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3f_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->set1Value(arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValue" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f___eq__" "', argument " "1"" of type '" "SoMFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f___eq__" "', argument " "2"" of type '" "SoMFVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f___eq__" "', argument " "2"" of type '" "SoMFVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  result = (SbBool)((SoMFVec3f const *)arg1)->operator ==((SoMFVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f___ne__" "', argument " "1"" of type '" "SoMFVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f___ne__" "', argument " "2"" of type '" "SoMFVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f___ne__" "', argument " "2"" of type '" "SoMFVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  result = (SbBool)((SoMFVec3f const *)arg1)->operator !=((SoMFVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_startEditing" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  result = (SbVec3f *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_finishEditing" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "3"" of type '" "SbVec3f const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec3f const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "3"" of type '" "SbVec3f *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3f_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3f_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3f_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3f_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::setValuesPointer(int const,SbVec3f const *)\n"
    "    SoMFVec3f::setValuesPointer(int const,SbVec3f *)\n"
    "    SoMFVec3f::setValuesPointer(int const,float const *)\n"
    "    SoMFVec3f::setValuesPointer(int const,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[3] = (float (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float (*temp4)[3] ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValues" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (float (*)[3]) malloc(len*3*sizeof(float));
      convert_SoMFVec3f_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      arg4 = NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(float const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PySequence_Check(argv[3])) {
              if (PySequence_Size(argv[3]) == 0) {
                _v = 1; 
              }
              else {
                PyObject * obj = PySequence_GetItem(argv[3], 0);
                void * ptr;
                if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec3f, 0) != -1) {
                  _v = 1; 
                }
                else {
                  _v = 0; 
                }
                Py_DECREF(obj);
              }
            }
            else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec3f_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if(PySequence_Check(argv[3]) && PySequence_Size(argv[3]) > 0 ){
              PyObject * obj = PySequence_GetItem(argv[3], 0);
              void * ptr;
              if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec3f, 0) == -1) {
                _v = 1; 
              }
              else {
                _v = 0; 
              }
              Py_DECREF(obj);
            } else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec3f_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::setValues(int const,int const,SbVec3f const *)\n"
    "    SoMFVec3f::setValues(int,int,float const [][3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_set1Value" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3f_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec3f_set1Value" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[3] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_set1Value" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec3f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3f_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void * ptr;
          _v = (PySequence_Check(argv[2]) && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_SoMFVec3f, 0) == -1) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFVec3f_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec3f_set1Value__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::set1Value(int const,SbVec3f const &)\n"
    "    SoMFVec3f::set1Value(int,float,float,float)\n"
    "    SoMFVec3f::set1Value(int,float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValue" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValue" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f___getitem__" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *) &SoMFVec3f___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f___setitem__" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3f___setitem__" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3f___setitem__" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoMFVec3f___setitem__(arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_setValue" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3f_setValue" "', argument " "2"" of type '" "SoMFVec3f const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  SoMFVec3f_setValue__SWIG_3(arg1,(SoMFVec3f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void * ptr;
        _v = (PySequence_Check(argv[1]) && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_SoMFVec3f, 0) == -1) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFVec3f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec3f_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::setValue(SbVec3f const &)\n"
    "    SoMFVec3f::setValue(float,float,float)\n"
    "    SoMFVec3f::setValue(float const [3])\n"
    "    SoMFVec3f::setValue(SoMFVec3f const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec3f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_getValues" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3f_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec3f *)SoMFVec3f___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec3f * Vec3fPtr = new SbVec3f(result[i]);
        PyObject * obj = SWIG_NewPointerObj(Vec3fPtr, SWIGTYPE_p_SbVec3f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3f *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbVec3f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3f_getValues" "', argument " "1"" of type '" "SoMFVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3f * >(argp1);
  result = (SbVec3f *)SoMFVec3f___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec3f * Vec3fPtr = new SbVec3f(result[i]);
        PyObject * obj = SWIG_NewPointerObj(Vec3fPtr, SWIGTYPE_p_SbVec3f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3f_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3f_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFVec3f_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFVec3f_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3f_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3f::__getValuesHelper__(int &,int)\n"
    "    SoMFVec3f::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFString", 0, 0, 0)) SWIG_fail;
  result = (SoMFString *)new SoMFString();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFString" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFString::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFString::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_getTypeId" "', argument " "1"" of type '" "SoMFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  result = ((SoMFString const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_copyFrom" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFString_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_isSame" "', argument " "1"" of type '" "SoMFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFString_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFString const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_find" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFString_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbString const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_find" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)(arg1)->find((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFString_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFString_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFString_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFString_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFString::find(SbString const &,SbBool)\n"
    "    SoMFString::find(SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbString *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_setValues" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFString_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFString_setValues" "', argument " "4"" of type '" "SbString const *""'"); 
  }
  arg4 = reinterpret_cast< SbString * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbString const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  SbString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_set1Value" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))  
    {
      arg3 = new SbString(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg3 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg3 = *tmp;
    }
  }
  (arg1)->set1Value(arg2,(SbString const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_setValue" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString___eq__" "', argument " "1"" of type '" "SoMFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFString,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString___eq__" "', argument " "2"" of type '" "SoMFString const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFString___eq__" "', argument " "2"" of type '" "SoMFString const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  result = (SbBool)((SoMFString const *)arg1)->operator ==((SoMFString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFString___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString___ne__" "', argument " "1"" of type '" "SoMFString const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFString,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString___ne__" "', argument " "2"" of type '" "SoMFString const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFString___ne__" "', argument " "2"" of type '" "SoMFString const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  result = (SbBool)((SoMFString const *)arg1)->operator !=((SoMFString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFString_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_startEditing" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  result = (SbString *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_finishEditing" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_initClass", 0, 0, 0)) SWIG_fail;
  SoMFString::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  char **arg4 = (char **)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_setValues" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFString_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;  
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = (char **)malloc(len * sizeof(char *));
        for (int i = 0; i < len; i++) {
          PyObject * item = PySequence_GetItem(swig_obj[3],i);
          if (PyBytes_Check(item))
          {
            arg4[i] = PyBytes_AsString(item);
          }
          else if  (PyUnicode_Check(item))
          {
            arg4[i] = PyBytes_AsString(PyUnicode_AsEncodedString(item, "utf-8", "Error ~"));
          }
          else
          {
            arg4[i] = PyBytes_AsString(PyUnicode_AsEncodedString(PyObject_Str(item), "utf-8", "Error ~"));
          }
          
          Py_DECREF(item);
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      return NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(char const *(*))arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFString_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFString_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = PySequence_Check(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_SoMFString_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFString_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFString::setValues(int const,int const,SbString const *)\n"
    "    SoMFString::setValues(int const,int const,char const *[])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_setValue" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString_setValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setValue((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_deleteText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString_deleteText", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_deleteText" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString_deleteText" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFString_deleteText" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFString_deleteText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFString_deleteText" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->deleteText(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString___getitem__" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbString *) &SoMFString___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int arg2 ;
  SbString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFString___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString___setitem__" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFString___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyBytes_Check(swig_obj[2]))  
    {
      arg3 = new SbString(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg3 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg3 = *tmp;
    }
  }
  SoMFString___setitem__(arg1,arg2,(SbString const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_setValue" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFString_setValue" "', argument " "2"" of type '" "SoMFString const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  SoMFString_setValue__SWIG_2(arg1,(SoMFString const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFString_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFString_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFString_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFString_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFString_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFString::setValue(SbString const &)\n"
    "    SoMFString::setValue(char const *)\n"
    "    SoMFString::setValue(SoMFString const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFString_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbString *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_getValues" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFString_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbString *)SoMFString___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyObject * str = 
        
        
        
        PyUnicode_DecodeUTF8(result[i].getString(), strlen(result[i].getString()), "Error ~");
        
        PyList_SetItem(resultobj, i, str);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFString *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbString *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFString_getValues" "', argument " "1"" of type '" "SoMFString *""'"); 
  }
  arg1 = reinterpret_cast< SoMFString * >(argp1);
  result = (SbString *)SoMFString___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyObject * str = 
        
        
        
        PyUnicode_DecodeUTF8(result[i].getString(), strlen(result[i].getString()), "Error ~");
        
        PyList_SetItem(resultobj, i, str);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFString_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFString_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFString_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFString_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFString_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFString::__getValuesHelper__(int &,int)\n"
    "    SoMFString::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFString, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFString_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCalculator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCalculator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_getTypeId" "', argument " "1"" of type '" "SoCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = ((SoCalculator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_getFieldData" "', argument " "1"" of type '" "SoCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoFieldData *)((SoCalculator const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_getOutputData" "', argument " "1"" of type '" "SoCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutputData *)((SoCalculator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCalculator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_a_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_a_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_a_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_a_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->a = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_a_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_a_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->a);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_b_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_b_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_b_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_b_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->b = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_b_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_b_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->b);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_c_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_c_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_c_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_c_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->c = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_c_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->c);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_d_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_d_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_d_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_d_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->d = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_d_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_d_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->d);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_e_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_e_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_e_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_e_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->e = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_e_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_e_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->e);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_f_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_f_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_f_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_f_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->f = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_f_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_f_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->f);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_g_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_g_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_g_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_g_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->g = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_g_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_g_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->g);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_h_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_h_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_h_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_h_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->h = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_h_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_h_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->h);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_A_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_A_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_A_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_A_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->A = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_A_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_A_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->A);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_B_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_B_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_B_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_B_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->B = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_B_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_B_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->B);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_C_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_C_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_C_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_C_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->C = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_C_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_C_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->C);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_D_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_D_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_D_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_D_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->D = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_D_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_D_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_E_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_E_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_E_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_E_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->E = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_E_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_E_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->E);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_F_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_F_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_F_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_F_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->F = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_F_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_F_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->F);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_G_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_G_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_G_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_G_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->G = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_G_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_G_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->G);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_H_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_H_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_H_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_H_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->H = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_H_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_H_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->H);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_expression_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_expression_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_expression_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_expression_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->expression = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_expression_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_expression_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoMFString *)& ((arg1)->expression);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oa_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oa_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oa_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oa_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oa = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oa_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oa_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oa);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_ob_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_ob_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_ob_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_ob_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->ob = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_ob_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_ob_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->ob);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oc_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oc_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oc = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oc_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_od_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_od_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_od_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_od_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->od = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_od_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_od_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->od);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oA_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oA_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oA = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oA_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oB_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oB_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oB_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oB_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oB = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oB_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oB);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oC_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oC_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oC = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oC_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oC);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oD_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_oD_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oD_set" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCalculator_oD_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->oD = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_oD_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCalculator_oD_get" "', argument " "1"" of type '" "SoCalculator *""'"); 
  }
  arg1 = reinterpret_cast< SoCalculator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->oD);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCalculator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCalculator", 0, 0, 0)) SWIG_fail;
  result = (SoCalculator *)new SoCalculator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCalculator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCalculator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCalculator_initClass", 0, 0, 0)) SWIG_fail;
  SoCalculator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCalculator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec2f", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec2f *)new SoMFVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec2f" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_getTypeId" "', argument " "1"" of type '" "SoMFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  result = ((SoMFVec2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_copyFrom" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_isSame" "', argument " "1"" of type '" "SoMFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec2f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_find" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_find" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_find" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec2f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_find" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_find" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_find" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (int)(arg1)->find((SbVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2f_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2f_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::find(SbVec2f const &,SbBool)\n"
    "    SoMFVec2f::find(SbVec2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec2f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValues" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbVec2f[len];
        for (int i = 0; i < len; i++) {
          SbVec2f * VecPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &VecPtr, SWIGTYPE_p_SbVec2f, 1);
          if (VecPtr != NULL) {
            arg4[i] = *VecPtr; 
          }
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbVec2f const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_set1Value" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2f_set1Value" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_set1Value" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->set1Value(arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValue" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f___eq__" "', argument " "1"" of type '" "SoMFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f___eq__" "', argument " "2"" of type '" "SoMFVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f___eq__" "', argument " "2"" of type '" "SoMFVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  result = (SbBool)((SoMFVec2f const *)arg1)->operator ==((SoMFVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f___ne__" "', argument " "1"" of type '" "SoMFVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f___ne__" "', argument " "2"" of type '" "SoMFVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f___ne__" "', argument " "2"" of type '" "SoMFVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  result = (SbBool)((SoMFVec2f const *)arg1)->operator !=((SoMFVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_startEditing" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  result = (SbVec2f *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_finishEditing" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "3"" of type '" "SbVec2f const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec2f const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "3"" of type '" "SbVec2f *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2f_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2f_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2f_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2f_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::setValuesPointer(int const,SbVec2f const *)\n"
    "    SoMFVec2f::setValuesPointer(int const,SbVec2f *)\n"
    "    SoMFVec2f::setValuesPointer(int const,float const *)\n"
    "    SoMFVec2f::setValuesPointer(int const,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[2] = (float (*)[2])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float (*temp4)[2] ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValues" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (float (*)[2]) malloc(len*2*sizeof(float));
      convert_SoMFVec2f_array(swig_obj[3], len, temp4);
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      arg4 = NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(float const (*)[2])arg4);
  resultobj = SWIG_Py_Void();
  {
    if(arg4) free(arg4);
  }
  return resultobj;
fail:
  {
    if(arg4) free(arg4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PySequence_Check(argv[3])) {
              if (PySequence_Size(argv[3]) == 0) {
                _v = 1; 
              }
              else {
                PyObject * obj = PySequence_GetItem(argv[3], 0);
                void * ptr;
                if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec2f, 0) != -1) {
                  _v = 1; 
                }
                else {
                  _v = 0; 
                }
                Py_DECREF(obj);
              }
            } else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec2f_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if(PySequence_Check(argv[3]) && PySequence_Size(argv[3]) > 0 ){
              PyObject * obj = PySequence_GetItem(argv[3], 0);
              void * ptr;
              if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec2f, 0) == -1) {
                _v = 1; 
              }
              else {
                _v = 0; 
              }
              Py_DECREF(obj);
            }
            else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec2f_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::setValues(int const,int const,SbVec2f const *)\n"
    "    SoMFVec2f::setValues(int,int,float const [][2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_set1Value" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec2f_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->set1Value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[2] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_set1Value" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec2f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_set1Value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2f_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          _v = (PySequence_Check(argv[2]) && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_SoMFVec2f, 0) == -1) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFVec2f_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec2f_set1Value__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::set1Value(int const,SbVec2f const &)\n"
    "    SoMFVec2f::set1Value(int,float,float)\n"
    "    SoMFVec2f::set1Value(int,float const [2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValue" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[2] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValue" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  {
    convert_SbVec2f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f___getitem__" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2f *) &SoMFVec2f___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int arg2 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f___setitem__" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2f___setitem__" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2f___setitem__" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  SoMFVec2f___setitem__(arg1,arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_setValue" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2f_setValue" "', argument " "2"" of type '" "SoMFVec2f const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  SoMFVec2f_setValue__SWIG_3(arg1,(SoMFVec2f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr;
        _v = (PySequence_Check(argv[1]) && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_SoMFVec2f, 0) == -1) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFVec2f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2f_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::setValue(SbVec2f const &)\n"
    "    SoMFVec2f::setValue(float,float)\n"
    "    SoMFVec2f::setValue(float const [2])\n"
    "    SoMFVec2f::setValue(SoMFVec2f const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec2f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_getValues" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2f_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec2f *)SoMFVec2f___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec2f * Vec2fPtr = new SbVec2f( result[i] );
        PyObject * obj = SWIG_NewPointerObj(Vec2fPtr, SWIGTYPE_p_SbVec2f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2f *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbVec2f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2f_getValues" "', argument " "1"" of type '" "SoMFVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2f * >(argp1);
  result = (SbVec2f *)SoMFVec2f___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec2f * Vec2fPtr = new SbVec2f( result[i] );
        PyObject * obj = SWIG_NewPointerObj(Vec2fPtr, SWIGTYPE_p_SbVec2f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2f_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2f_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFVec2f_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFVec2f_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2f_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2f::__getValuesHelper__(int &,int)\n"
    "    SoMFVec2f::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeVec2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeVec2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_getTypeId" "', argument " "1"" of type '" "SoComposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = ((SoComposeVec2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_getFieldData" "', argument " "1"" of type '" "SoComposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = (SoFieldData *)((SoComposeVec2f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_getOutputData" "', argument " "1"" of type '" "SoComposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = (SoEngineOutputData *)((SoComposeVec2f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeVec2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeVec2f", 0, 0, 0)) SWIG_fail;
  result = (SoComposeVec2f *)new SoComposeVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeVec2f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeVec2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_x_set" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec2f_x_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_x_get" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_y_set" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec2f_y_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_y_get" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec2f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_vector_set" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec2f_vector_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec2f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec2f_vector_get" "', argument " "1"" of type '" "SoComposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec2f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_getTypeId" "', argument " "1"" of type '" "SoComposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = ((SoComposeVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_getFieldData" "', argument " "1"" of type '" "SoComposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoFieldData *)((SoComposeVec3f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_getOutputData" "', argument " "1"" of type '" "SoComposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoEngineOutputData *)((SoComposeVec3f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoComposeVec3f *)new SoComposeVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeVec3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_x_set" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec3f_x_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_x_get" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_y_set" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec3f_y_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_y_get" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_z_set" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec3f_z_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->z = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_z_get" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->z);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec3f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_vector_set" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec3f_vector_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec3f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec3f_vector_get" "', argument " "1"" of type '" "SoComposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4f", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4f *)new SoMFVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4f" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_getTypeId" "', argument " "1"" of type '" "SoMFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  result = ((SoMFVec4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_copyFrom" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_isSame" "', argument " "1"" of type '" "SoMFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_find" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_find" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_find" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_find" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_find" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_find" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (int)(arg1)->find((SbVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4f_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4f_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::find(SbVec4f const &,SbBool)\n"
    "    SoMFVec4f::find(SbVec4f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValues" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbVec4f[len];
        for (int i = 0; i < len; i++) {
          SbVec4f * VecPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &VecPtr, SWIGTYPE_p_SbVec4f, 1);
          if (VecPtr != NULL) {
            arg4[i] = *VecPtr; 
          }
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbVec4f const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_set1Value" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4f_set1Value" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_set1Value" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4f * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValue" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f___eq__" "', argument " "1"" of type '" "SoMFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f___eq__" "', argument " "2"" of type '" "SoMFVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f___eq__" "', argument " "2"" of type '" "SoMFVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  result = (SbBool)((SoMFVec4f const *)arg1)->operator ==((SoMFVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f___ne__" "', argument " "1"" of type '" "SoMFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f___ne__" "', argument " "2"" of type '" "SoMFVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f___ne__" "', argument " "2"" of type '" "SoMFVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  result = (SbBool)((SoMFVec4f const *)arg1)->operator !=((SoMFVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_startEditing" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  result = (SbVec4f *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_finishEditing" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "3"" of type '" "SbVec4f const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4f * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4f const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "3"" of type '" "SbVec4f *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4f * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4f_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4f_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4f_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4f_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::setValuesPointer(int const,SbVec4f const *)\n"
    "    SoMFVec4f::setValuesPointer(int const,SbVec4f *)\n"
    "    SoMFVec4f::setValuesPointer(int const,float const *)\n"
    "    SoMFVec4f::setValuesPointer(int const,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[4] = (float (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float (*temp4)[4] ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValues" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (float(*)[4])malloc(len*4*sizeof(float));
      convert_SoMFVec4f_array(swig_obj[3], len, temp4);
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      arg4 = NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(float const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PySequence_Check(argv[3])) {
              if (PySequence_Size(argv[3]) == 0) {
                _v = 1;
              } else {
                PyObject * obj = PySequence_GetItem(argv[3],0);
                void *ptr;
                if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec4f, 0) != -1) {
                  _v = 1; 
                }
                else {
                  _v = 0; 
                }
                Py_DECREF(obj);
              }
            } else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec4f_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = 0;
            if (PySequence_Check(argv[3]) && PySequence_Size(argv[3]) > 0 ) {
              PyObject * obj = PySequence_GetItem(argv[3],0);
              void *ptr;
              if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec4f, 0) == -1) {
                _v = 1; 
              }
              Py_DECREF(obj);
            }
          }
          if (_v) {
            return _wrap_SoMFVec4f_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::setValues(int const,int const,SbVec4f const *)\n"
    "    SoMFVec4f::setValues(int,int,float const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_set1Value" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4f_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4f_set1Value" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4f_set1Value" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[4] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_set1Value" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec4f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4f_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          _v = (PySequence_Check(argv[2]) && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_SoMFVec4f, 0) == -1) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFVec4f_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4f_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::set1Value(int const,SbVec4f const &)\n"
    "    SoMFVec4f::set1Value(int,float,float,float,float)\n"
    "    SoMFVec4f::set1Value(int,float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValue" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValue" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f___getitem__" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4f *) &SoMFVec4f___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int arg2 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4f___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f___setitem__" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4f___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4f___setitem__" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4f___setitem__" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4f * >(argp3);
  SoMFVec4f___setitem__(arg1,arg2,(SbVec4f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_setValue" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4f_setValue" "', argument " "2"" of type '" "SoMFVec4f const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  SoMFVec4f_setValue__SWIG_3(arg1,(SoMFVec4f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr;
        _v = (PySequence_Check(argv[1]) && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_SoMFVec4f, 0) == -1) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFVec4f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4f_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::setValue(SbVec4f const &)\n"
    "    SoMFVec4f::setValue(float,float,float,float)\n"
    "    SoMFVec4f::setValue(float const [4])\n"
    "    SoMFVec4f::setValue(SoMFVec4f const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec4f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_getValues" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4f_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec4f *)SoMFVec4f___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec4f * Vec4fPtr = new SbVec4f( result[i] );
        PyObject * obj = SWIG_NewPointerObj(Vec4fPtr, SWIGTYPE_p_SbVec4f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4f *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbVec4f *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4f_getValues" "', argument " "1"" of type '" "SoMFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4f * >(argp1);
  result = (SbVec4f *)SoMFVec4f___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec4f * Vec4fPtr = new SbVec4f( result[i] );
        PyObject * obj = SWIG_NewPointerObj(Vec4fPtr, SWIGTYPE_p_SbVec4f, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4f_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4f_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFVec4f_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFVec4f_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4f_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4f::__getValuesHelper__(int &,int)\n"
    "    SoMFVec4f::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeVec4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeVec4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_getTypeId" "', argument " "1"" of type '" "SoComposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = ((SoComposeVec4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_getFieldData" "', argument " "1"" of type '" "SoComposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoFieldData *)((SoComposeVec4f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_getOutputData" "', argument " "1"" of type '" "SoComposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoEngineOutputData *)((SoComposeVec4f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeVec4f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeVec4f", 0, 0, 0)) SWIG_fail;
  result = (SoComposeVec4f *)new SoComposeVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeVec4f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeVec4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_x_set" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec4f_x_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_x_get" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_y_set" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec4f_y_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_y_get" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_z_set" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec4f_z_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->z = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_z_get" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->z);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_w_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_w_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_w_set" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec4f_w_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->w = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_w_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_w_get" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->w);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeVec4f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_vector_set" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeVec4f_vector_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeVec4f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeVec4f_vector_get" "', argument " "1"" of type '" "SoComposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeVec4f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecomposeVec2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_getTypeId" "', argument " "1"" of type '" "SoDecomposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = ((SoDecomposeVec2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_getFieldData" "', argument " "1"" of type '" "SoDecomposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = (SoFieldData *)((SoDecomposeVec2f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_getOutputData" "', argument " "1"" of type '" "SoDecomposeVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = (SoEngineOutputData *)((SoDecomposeVec2f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecomposeVec2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDecomposeVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDecomposeVec2f", 0, 0, 0)) SWIG_fail;
  result = (SoDecomposeVec2f *)new SoDecomposeVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDecomposeVec2f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_initClass", 0, 0, 0)) SWIG_fail;
  SoDecomposeVec2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_vector_set" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec2f_vector_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_vector_get" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_x_set" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec2f_x_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_x_get" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec2f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_y_set" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec2f_y_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec2f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec2f_y_get" "', argument " "1"" of type '" "SoDecomposeVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec2f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecomposeVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecomposeVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDecomposeVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecomposeVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_getTypeId" "', argument " "1"" of type '" "SoDecomposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = ((SoDecomposeVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_getFieldData" "', argument " "1"" of type '" "SoDecomposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoFieldData *)((SoDecomposeVec3f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_getOutputData" "', argument " "1"" of type '" "SoDecomposeVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoEngineOutputData *)((SoDecomposeVec3f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecomposeVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDecomposeVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDecomposeVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoDecomposeVec3f *)new SoDecomposeVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDecomposeVec3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoDecomposeVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_vector_set" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec3f_vector_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_vector_get" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_x_set" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec3f_x_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_x_get" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_y_set" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec3f_y_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_y_get" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec3f_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_z_set" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec3f_z_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->z = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec3f_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec3f_z_get" "', argument " "1"" of type '" "SoDecomposeVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->z);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecomposeVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecomposeVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDecomposeVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecomposeVec4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_getTypeId" "', argument " "1"" of type '" "SoDecomposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = ((SoDecomposeVec4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_getFieldData" "', argument " "1"" of type '" "SoDecomposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoFieldData *)((SoDecomposeVec4f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_getOutputData" "', argument " "1"" of type '" "SoDecomposeVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoEngineOutputData *)((SoDecomposeVec4f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecomposeVec4f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDecomposeVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDecomposeVec4f", 0, 0, 0)) SWIG_fail;
  result = (SoDecomposeVec4f *)new SoDecomposeVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDecomposeVec4f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_initClass", 0, 0, 0)) SWIG_fail;
  SoDecomposeVec4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_vector_set" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec4f_vector_set" "', argument " "2"" of type '" "SoMFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_vector_get" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoMFVec4f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_x_set" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec4f_x_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_x_get" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->x);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_y_set" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec4f_y_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->y = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_y_get" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->y);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_z_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_z_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_z_set" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec4f_z_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->z = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_z_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_z_get" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->z);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_w_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeVec4f_w_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_w_set" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeVec4f_w_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->w = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeVec4f_w_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeVec4f_w_get" "', argument " "1"" of type '" "SoDecomposeVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeVec4f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->w);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecomposeVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecomposeVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDecomposeVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_getTypeId" "', argument " "1"" of type '" "SoComposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = ((SoComposeRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_getFieldData" "', argument " "1"" of type '" "SoComposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = (SoFieldData *)((SoComposeRotation const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_getOutputData" "', argument " "1"" of type '" "SoComposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = (SoEngineOutputData *)((SoComposeRotation const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeRotation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeRotation", 0, 0, 0)) SWIG_fail;
  result = (SoComposeRotation *)new SoComposeRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeRotation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_axis_set" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotation_axis_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->axis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_axis_get" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->axis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_angle_set" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotation_angle_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->angle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_angle_get" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = (SoMFFloat *)& ((arg1)->angle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotation_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_rotation_set" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotation_rotation_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotation_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotation_rotation_get" "', argument " "1"" of type '" "SoComposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotation * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFRotation", 0, 0, 0)) SWIG_fail;
  result = (SoMFRotation *)new SoMFRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFRotation" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFRotation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_getTypeId" "', argument " "1"" of type '" "SoMFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  result = ((SoMFRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_copyFrom" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_isSame" "', argument " "1"" of type '" "SoMFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFRotation const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_find" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_find" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_find" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbRotation const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_find" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_find" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_find" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  result = (int)(arg1)->find((SbRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFRotation_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFRotation_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFRotation_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFRotation_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFRotation::find(SbRotation const &,SbBool)\n"
    "    SoMFRotation::find(SbRotation const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbRotation *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValues" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbRotation[len];
        for (int i = 0; i < len; i++) {
          SbRotation * RotationPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &RotationPtr, SWIGTYPE_p_SbRotation, 1);
          if( RotationPtr != NULL )
          arg4[i] = *RotationPtr;
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbRotation const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_set1Value" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFRotation_set1Value" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_set1Value" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  (arg1)->set1Value(arg2,(SbRotation const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValue" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  (arg1)->setValue((SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation___eq__" "', argument " "1"" of type '" "SoMFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation___eq__" "', argument " "2"" of type '" "SoMFRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation___eq__" "', argument " "2"" of type '" "SoMFRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  result = (SbBool)((SoMFRotation const *)arg1)->operator ==((SoMFRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFRotation___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation___ne__" "', argument " "1"" of type '" "SoMFRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation___ne__" "', argument " "2"" of type '" "SoMFRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation___ne__" "', argument " "2"" of type '" "SoMFRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  result = (SbBool)((SoMFRotation const *)arg1)->operator !=((SoMFRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_startEditing" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  result = (SbRotation *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_finishEditing" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoMFRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[4] = (float (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValues" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFRotation_setValues" "', argument " "4"" of type '" "float const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< float (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(float const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFRotation_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = PySequence_Check(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_SoMFRotation_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFRotation_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFRotation_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFRotation::setValues(int const,int const,SbRotation const *)\n"
    "    SoMFRotation::setValues(int const,int const,float const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_set1Value" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFRotation_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFRotation_set1Value" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFRotation_set1Value" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[4] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_set1Value" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec4f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_set1Value__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_set1Value" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFRotation_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFRotation_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->set1Value(arg2,(SbVec3f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFRotation_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFRotation_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = PySequence_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFRotation_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFRotation_set1Value__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFRotation_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFRotation_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFRotation::set1Value(int const,SbRotation const &)\n"
    "    SoMFRotation::set1Value(int const,float const,float const,float const,float const)\n"
    "    SoMFRotation::set1Value(int const,float const [4])\n"
    "    SoMFRotation::set1Value(int const,SbVec3f const &,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValue" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFRotation_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFRotation_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValue" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValue" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation___getitem__" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbRotation *) &SoMFRotation___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int arg2 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFRotation___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation___setitem__" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFRotation___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFRotation___setitem__" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFRotation___setitem__" "', argument " "3"" of type '" "SbRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  SoMFRotation___setitem__(arg1,arg2,(SbRotation const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbRotation *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_getValues" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFRotation_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbRotation *)SoMFRotation___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbRotation * RotationPtr = new SbRotation( result[i] );
        PyObject * obj = SWIG_NewPointerObj(RotationPtr, SWIGTYPE_p_SbRotation, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbRotation *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_getValues" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  result = (SbRotation *)SoMFRotation___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbRotation * RotationPtr = new SbRotation( result[i] );
        PyObject * obj = SWIG_NewPointerObj(RotationPtr, SWIGTYPE_p_SbRotation, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFRotation_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFRotation_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFRotation_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFRotation_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFRotation::__getValuesHelper__(int &,int)\n"
    "    SoMFRotation::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFRotation_setValue" "', argument " "1"" of type '" "SoMFRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoMFRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFRotation_setValue" "', argument " "2"" of type '" "SoMFRotation const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  SoMFRotation_setValue__SWIG_4(arg1,(SoMFRotation const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFRotation_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFRotation_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFRotation_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFRotation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFRotation_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFRotation_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFRotation_setValue__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFRotation_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFRotation_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFRotation::setValue(SbRotation const &)\n"
    "    SoMFRotation::setValue(float const,float const,float const,float const)\n"
    "    SoMFRotation::setValue(float const [4])\n"
    "    SoMFRotation::setValue(SbVec3f const &,float const)\n"
    "    SoMFRotation::setValue(SoMFRotation const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDecomposeRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecomposeRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_getTypeId" "', argument " "1"" of type '" "SoDecomposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = ((SoDecomposeRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_getFieldData" "', argument " "1"" of type '" "SoDecomposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = (SoFieldData *)((SoDecomposeRotation const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_getOutputData" "', argument " "1"" of type '" "SoDecomposeRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = (SoEngineOutputData *)((SoDecomposeRotation const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecomposeRotation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDecomposeRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDecomposeRotation", 0, 0, 0)) SWIG_fail;
  result = (SoDecomposeRotation *)new SoDecomposeRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDecomposeRotation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoDecomposeRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_rotation_set" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeRotation_rotation_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_rotation_get" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = (SoMFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_axis_set" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeRotation_axis_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->axis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_axis_get" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->axis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeRotation_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_angle_set" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeRotation_angle_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->angle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeRotation_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeRotation_angle_get" "', argument " "1"" of type '" "SoDecomposeRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeRotation * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->angle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecomposeRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecomposeRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDecomposeRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeMatrix_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeMatrix::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_getTypeId" "', argument " "1"" of type '" "SoComposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = ((SoComposeMatrix const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_getFieldData" "', argument " "1"" of type '" "SoComposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoFieldData *)((SoComposeMatrix const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_getOutputData" "', argument " "1"" of type '" "SoComposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoEngineOutputData *)((SoComposeMatrix const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeMatrix::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeMatrix", 0, 0, 0)) SWIG_fail;
  result = (SoComposeMatrix *)new SoComposeMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeMatrix, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeMatrix::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_translation_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_translation_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_translation_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_rotation_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_rotation_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_rotation_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoMFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_scaleFactor_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_scaleFactor_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_scaleFactor_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_scaleOrientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_scaleOrientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_scaleOrientation_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_scaleOrientation_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->scaleOrientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_scaleOrientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_scaleOrientation_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoMFRotation *)& ((arg1)->scaleOrientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_center_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_center_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_center_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeMatrix_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_matrix_set" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeMatrix_matrix_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeMatrix_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeMatrix_matrix_get" "', argument " "1"" of type '" "SoComposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeMatrix * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFMatrix", 0, 0, 0)) SWIG_fail;
  result = (SoMFMatrix *)new SoMFMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFMatrix" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFMatrix::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFMatrix::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_getTypeId" "', argument " "1"" of type '" "SoMFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  result = ((SoMFMatrix const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_copyFrom" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_isSame" "', argument " "1"" of type '" "SoMFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFMatrix const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_find" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_find" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_find" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFMatrix_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbMatrix const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_find" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_find" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_find" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  result = (int)(arg1)->find((SbMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFMatrix_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFMatrix_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFMatrix_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFMatrix_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFMatrix::find(SbMatrix const &,SbBool)\n"
    "    SoMFMatrix::find(SbMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_setValues" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFMatrix_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFMatrix_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbMatrix[len];
        for (int i = 0; i < len; i++) {
          SbMatrix * matPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &matPtr, SWIGTYPE_p_SbMatrix, 1);
          if (matPtr != NULL) {
            arg4[i] = *matPtr; 
          }
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbMatrix const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int arg2 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_set1Value" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFMatrix_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFMatrix_set1Value" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_set1Value" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  (arg1)->set1Value(arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_setValue" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setValue((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix___eq__" "', argument " "1"" of type '" "SoMFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix___eq__" "', argument " "2"" of type '" "SoMFMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix___eq__" "', argument " "2"" of type '" "SoMFMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  result = (SbBool)((SoMFMatrix const *)arg1)->operator ==((SoMFMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix___ne__" "', argument " "1"" of type '" "SoMFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix___ne__" "', argument " "2"" of type '" "SoMFMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix___ne__" "', argument " "2"" of type '" "SoMFMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  result = (SbBool)((SoMFMatrix const *)arg1)->operator !=((SoMFMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_startEditing" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  result = (SbMatrix *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_finishEditing" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix_initClass", 0, 0, 0)) SWIG_fail;
  SoMFMatrix::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  float arg8 ;
  float arg9 ;
  float arg10 ;
  float arg11 ;
  float arg12 ;
  float arg13 ;
  float arg14 ;
  float arg15 ;
  float arg16 ;
  float arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  float val14 ;
  int ecode14 = 0 ;
  float val15 ;
  int ecode15 = 0 ;
  float val16 ;
  int ecode16 = 0 ;
  float val17 ;
  int ecode17 = 0 ;
  
  (void)self;
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_setValue" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFMatrix_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFMatrix_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFMatrix_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFMatrix_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFMatrix_setValue" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoMFMatrix_setValue" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoMFMatrix_setValue" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_float(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoMFMatrix_setValue" "', argument " "9"" of type '" "float""'");
  } 
  arg9 = static_cast< float >(val9);
  ecode10 = SWIG_AsVal_float(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoMFMatrix_setValue" "', argument " "10"" of type '" "float""'");
  } 
  arg10 = static_cast< float >(val10);
  ecode11 = SWIG_AsVal_float(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoMFMatrix_setValue" "', argument " "11"" of type '" "float""'");
  } 
  arg11 = static_cast< float >(val11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoMFMatrix_setValue" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  ecode13 = SWIG_AsVal_float(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SoMFMatrix_setValue" "', argument " "13"" of type '" "float""'");
  } 
  arg13 = static_cast< float >(val13);
  ecode14 = SWIG_AsVal_float(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "SoMFMatrix_setValue" "', argument " "14"" of type '" "float""'");
  } 
  arg14 = static_cast< float >(val14);
  ecode15 = SWIG_AsVal_float(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "SoMFMatrix_setValue" "', argument " "15"" of type '" "float""'");
  } 
  arg15 = static_cast< float >(val15);
  ecode16 = SWIG_AsVal_float(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "SoMFMatrix_setValue" "', argument " "16"" of type '" "float""'");
  } 
  arg16 = static_cast< float >(val16);
  ecode17 = SWIG_AsVal_float(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "SoMFMatrix_setValue" "', argument " "17"" of type '" "float""'");
  } 
  arg17 = static_cast< float >(val17);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix___getitem__" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFMatrix___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbMatrix *) &SoMFMatrix___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int arg2 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFMatrix___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix___setitem__" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFMatrix___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFMatrix___setitem__" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFMatrix___setitem__" "', argument " "3"" of type '" "SbMatrix const &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  SoMFMatrix___setitem__(arg1,arg2,(SbMatrix const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbMatrix *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_getValues" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFMatrix_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbMatrix *)SoMFMatrix___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbMatrix * matPtr = new SbMatrix( result[i] );
        PyObject * obj = SWIG_NewPointerObj(matPtr, SWIGTYPE_p_SbMatrix, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbMatrix *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_getValues" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  result = (SbMatrix *)SoMFMatrix___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbMatrix * matPtr = new SbMatrix( result[i] );
        PyObject * obj = SWIG_NewPointerObj(matPtr, SWIGTYPE_p_SbMatrix, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFMatrix_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFMatrix_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFMatrix_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFMatrix_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFMatrix::__getValuesHelper__(int &,int)\n"
    "    SoMFMatrix::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFMatrix *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFMatrix_setValue" "', argument " "1"" of type '" "SoMFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoMFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFMatrix_setValue" "', argument " "2"" of type '" "SoMFMatrix const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  SoMFMatrix_setValue__SWIG_2(arg1,(SoMFMatrix const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFMatrix_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[18] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFMatrix_setValue", 0, 17, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFMatrix_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFMatrix_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_float(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_float(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_float(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_float(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_SoMFMatrix_setValue__SWIG_1(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFMatrix_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFMatrix::setValue(SbMatrix const &)\n"
    "    SoMFMatrix::setValue(float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const)\n"
    "    SoMFMatrix::setValue(SoMFMatrix const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDecomposeMatrix::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_getTypeId" "', argument " "1"" of type '" "SoDecomposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = ((SoDecomposeMatrix const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_getFieldData" "', argument " "1"" of type '" "SoDecomposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoFieldData *)((SoDecomposeMatrix const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_getOutputData" "', argument " "1"" of type '" "SoDecomposeMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoEngineOutputData *)((SoDecomposeMatrix const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoDecomposeMatrix::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDecomposeMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDecomposeMatrix", 0, 0, 0)) SWIG_fail;
  result = (SoDecomposeMatrix *)new SoDecomposeMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDecomposeMatrix, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_initClass", 0, 0, 0)) SWIG_fail;
  SoDecomposeMatrix::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_matrix_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_matrix_set" "', argument " "2"" of type '" "SoMFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_matrix_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoMFMatrix *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_center_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_center_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_center_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_translation_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_translation_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_translation_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_rotation_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_rotation_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_rotation_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_scaleFactor_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_scaleFactor_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_scaleFactor_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_scaleOrientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDecomposeMatrix_scaleOrientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_scaleOrientation_set" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDecomposeMatrix_scaleOrientation_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->scaleOrientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDecomposeMatrix_scaleOrientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDecomposeMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDecomposeMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDecomposeMatrix_scaleOrientation_get" "', argument " "1"" of type '" "SoDecomposeMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoDecomposeMatrix * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->scaleOrientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDecomposeMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDecomposeMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDecomposeMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComposeRotationFromTo::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_getTypeId" "', argument " "1"" of type '" "SoComposeRotationFromTo const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = ((SoComposeRotationFromTo const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_getFieldData" "', argument " "1"" of type '" "SoComposeRotationFromTo const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = (SoFieldData *)((SoComposeRotationFromTo const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_getOutputData" "', argument " "1"" of type '" "SoComposeRotationFromTo const *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = (SoEngineOutputData *)((SoComposeRotationFromTo const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComposeRotationFromTo::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComposeRotationFromTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComposeRotationFromTo", 0, 0, 0)) SWIG_fail;
  result = (SoComposeRotationFromTo *)new SoComposeRotationFromTo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComposeRotationFromTo, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_initClass", 0, 0, 0)) SWIG_fail;
  SoComposeRotationFromTo::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_srcFrom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_srcFrom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_srcFrom_set" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotationFromTo_srcFrom_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->from = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_srcFrom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_srcFrom_get" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->from);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_destTo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_destTo_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_destTo_set" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotationFromTo_destTo_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->to = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_destTo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_destTo_get" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->to);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComposeRotationFromTo_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_rotation_set" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComposeRotationFromTo_rotation_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComposeRotationFromTo_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComposeRotationFromTo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComposeRotationFromTo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComposeRotationFromTo_rotation_get" "', argument " "1"" of type '" "SoComposeRotationFromTo *""'"); 
  }
  arg1 = reinterpret_cast< SoComposeRotationFromTo * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComposeRotationFromTo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComposeRotationFromTo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComposeRotationFromTo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFPath", 0, 0, 0)) SWIG_fail;
  result = (SoSFPath *)new SoSFPath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFPath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFPath" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFPath::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFPath::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_getTypeId" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  result = ((SoSFPath const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_copyFrom" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPath_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_isSame" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPath_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFPath const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_getValue" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  result = (SoPath *)((SoSFPath const *)arg1)->getValue();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_setValue" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath_setValue" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoSFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath___eq__" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath___eq__" "', argument " "2"" of type '" "SoSFPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPath___eq__" "', argument " "2"" of type '" "SoSFPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFPath * >(argp2);
  result = (int)((SoSFPath const *)arg1)->operator ==((SoSFPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFPath___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoSFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath___ne__" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath___ne__" "', argument " "2"" of type '" "SoSFPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPath___ne__" "', argument " "2"" of type '" "SoSFPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFPath * >(argp2);
  result = (int)((SoSFPath const *)arg1)->operator !=((SoSFPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFPath_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_initClass", 0, 0, 0)) SWIG_fail;
  SoSFPath::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_notify" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPath_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_fixCopy" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFPath_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_referencesCopy" "', argument " "1"" of type '" "SoSFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  result = (SbBool)((SoSFPath const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFPath *arg1 = 0 ;
  SoSFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPath_setValue" "', argument " "1"" of type '" "SoSFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPath_setValue" "', argument " "2"" of type '" "SoSFPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFPath * >(argp2);
  SoSFPath_setValue__SWIG_1(arg1,(SoSFPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPath_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFPath_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFPath_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFPath_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFPath_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFPath::setValue(SoPath *)\n"
    "    SoSFPath::setValue(SoSFPath const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFPath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoComputeBoundingBox::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_getTypeId" "', argument " "1"" of type '" "SoComputeBoundingBox const *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = ((SoComputeBoundingBox const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_getFieldData" "', argument " "1"" of type '" "SoComputeBoundingBox const *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoFieldData *)((SoComputeBoundingBox const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_getOutputData" "', argument " "1"" of type '" "SoComputeBoundingBox const *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoEngineOutputData *)((SoComputeBoundingBox const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoComputeBoundingBox::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_node_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_node_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_node_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_node_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->node = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_node_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_node_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoSFNode *)& ((arg1)->node);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoSFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_path_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_path_set" "', argument " "2"" of type '" "SoSFPath *""'"); 
  }
  arg2 = reinterpret_cast< SoSFPath * >(argp2);
  if (arg1) (arg1)->path = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_path_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoSFPath *)& ((arg1)->path);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFPath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_min_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_min_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_min_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_max_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_max_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_max_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_boxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_boxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_boxCenter_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_boxCenter_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->boxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_boxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_boxCenter_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->boxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_objectCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_objectCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_objectCenter_set" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_objectCenter_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->objectCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_objectCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_objectCenter_get" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->objectCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoComputeBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoComputeBoundingBox", 0, 0, 0)) SWIG_fail;
  result = (SoComputeBoundingBox *)new SoComputeBoundingBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoComputeBoundingBox, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_initClass", 0, 0, 0)) SWIG_fail;
  SoComputeBoundingBox::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoComputeBoundingBox_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_setViewportRegion" "', argument " "1"" of type '" "SoComputeBoundingBox *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoComputeBoundingBox_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoComputeBoundingBox_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoComputeBoundingBox_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoComputeBoundingBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoComputeBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoComputeBoundingBox_getViewportRegion" "', argument " "1"" of type '" "SoComputeBoundingBox const *""'"); 
  }
  arg1 = reinterpret_cast< SoComputeBoundingBox * >(argp1);
  result = (SbViewportRegion *) &((SoComputeBoundingBox const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoComputeBoundingBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoComputeBoundingBox, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoComputeBoundingBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoConcatenate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConcatenate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoConcatenate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_getTypeId" "', argument " "1"" of type '" "SoConcatenate const *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  result = ((SoConcatenate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_getFieldData" "', argument " "1"" of type '" "SoConcatenate const *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  result = (SoFieldData *)((SoConcatenate const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_getOutputData" "', argument " "1"" of type '" "SoConcatenate const *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  result = (SoEngineOutputData *)((SoConcatenate const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConcatenate_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoConcatenate::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConcatenate_initClass", 0, 0, 0)) SWIG_fail;
  SoConcatenate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoConcatenate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoConcatenate *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoConcatenate" "', argument " "1"" of type '" "SoType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoConcatenate" "', argument " "1"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (SoConcatenate *)new SoConcatenate(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoConcatenate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_input_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  SoMField **arg2 = (SoMField **)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConcatenate_input_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_input_set" "', argument " "1"" of type '" "SoConcatenate *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_SoMField, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoConcatenate_input_set" "', argument " "2"" of type '" "SoMField *[SoConcatenate::NUMINPUTS]""'"); 
  } 
  arg2 = reinterpret_cast< SoMField ** >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)SoConcatenate::NUMINPUTS; ++ii) *(SoMField * *)&arg1->input[ii] = *((SoMField * *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""input""' of type '""SoMField *[SoConcatenate::NUMINPUTS]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_input_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMField **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_input_get" "', argument " "1"" of type '" "SoConcatenate *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  result = (SoMField **)(SoMField **) ((arg1)->input);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoMField, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoConcatenate_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_output_set" "', argument " "1"" of type '" "SoConcatenate *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoConcatenate_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoConcatenate_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoConcatenate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoConcatenate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoConcatenate_output_get" "', argument " "1"" of type '" "SoConcatenate *""'"); 
  }
  arg1 = reinterpret_cast< SoConcatenate * >(argp1);
  result = (SoEngineOutput *) ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoConcatenate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoConcatenate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoConcatenate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFTrigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFTrigger", 0, 0, 0)) SWIG_fail;
  result = (SoSFTrigger *)new SoSFTrigger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFTrigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFTrigger" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFTrigger::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFTrigger::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_getTypeId" "', argument " "1"" of type '" "SoSFTrigger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  result = ((SoSFTrigger const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_copyFrom" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTrigger_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_isSame" "', argument " "1"" of type '" "SoSFTrigger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTrigger_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFTrigger const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_initClass", 0, 0, 0)) SWIG_fail;
  SoSFTrigger::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_setValue" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  (arg1)->setValue();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_getValue" "', argument " "1"" of type '" "SoSFTrigger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  ((SoSFTrigger const *)arg1)->getValue();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger___eq__" "', argument " "1"" of type '" "SoSFTrigger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFTrigger,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger___eq__" "', argument " "2"" of type '" "SoSFTrigger const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTrigger___eq__" "', argument " "2"" of type '" "SoSFTrigger const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  result = (int)((SoSFTrigger const *)arg1)->operator ==((SoSFTrigger const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger___ne__" "', argument " "1"" of type '" "SoSFTrigger const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFTrigger,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger___ne__" "', argument " "2"" of type '" "SoSFTrigger const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTrigger___ne__" "', argument " "2"" of type '" "SoSFTrigger const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  result = (int)((SoSFTrigger const *)arg1)->operator !=((SoSFTrigger const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_startNotify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_startNotify" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  (arg1)->startNotify();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTrigger_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_notify" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_touch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_touch" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  (arg1)->touch();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFTrigger *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTrigger_setValue" "', argument " "1"" of type '" "SoSFTrigger *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTrigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTrigger_setValue" "', argument " "2"" of type '" "SoSFTrigger const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  SoSFTrigger_setValue__SWIG_1(arg1,(SoSFTrigger const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTrigger_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFTrigger_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFTrigger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFTrigger_setValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFTrigger, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFTrigger, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFTrigger_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFTrigger_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFTrigger::setValue()\n"
    "    SoSFTrigger::setValue(SoSFTrigger const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFTrigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFTrigger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFTrigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFShort", 0, 0, 0)) SWIG_fail;
  result = (SoSFShort *)new SoSFShort();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFShort" "', argument " "1"" of type '" "SoSFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFShort::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFShort::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_getTypeId" "', argument " "1"" of type '" "SoSFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  result = ((SoSFShort const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_copyFrom" "', argument " "1"" of type '" "SoSFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_isSame" "', argument " "1"" of type '" "SoSFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFShort const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_getValue" "', argument " "1"" of type '" "SoSFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  result = (short)((SoSFShort const *)arg1)->getValue();
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_setValue" "', argument " "1"" of type '" "SoSFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFShort_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort___eq__" "', argument " "1"" of type '" "SoSFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFShort___eq__" "', argument " "2"" of type '" "SoSFShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFShort___eq__" "', argument " "2"" of type '" "SoSFShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  result = (int)((SoSFShort const *)arg1)->operator ==((SoSFShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFShort___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort___ne__" "', argument " "1"" of type '" "SoSFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFShort___ne__" "', argument " "2"" of type '" "SoSFShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFShort___ne__" "', argument " "2"" of type '" "SoSFShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  result = (int)((SoSFShort const *)arg1)->operator !=((SoSFShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFShort_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFShort_initClass", 0, 0, 0)) SWIG_fail;
  SoSFShort::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFShort *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFShort_setValue" "', argument " "1"" of type '" "SoSFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoSFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFShort_setValue" "', argument " "2"" of type '" "SoSFShort const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  SoSFShort_setValue__SWIG_1(arg1,(SoSFShort const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFShort_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFShort_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFShort, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFShort_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFShort_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFShort_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFShort::setValue(short)\n"
    "    SoSFShort::setValue(SoSFShort const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFShort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFShort, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFShort_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCounter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCounter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_getTypeId" "', argument " "1"" of type '" "SoCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = ((SoCounter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_getFieldData" "', argument " "1"" of type '" "SoCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoFieldData *)((SoCounter const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_getOutputData" "', argument " "1"" of type '" "SoCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoEngineOutputData *)((SoCounter const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCounter::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_initClass", 0, 0, 0)) SWIG_fail;
  SoCounter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCounter", 0, 0, 0)) SWIG_fail;
  result = (SoCounter *)new SoCounter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCounter, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_min_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_min_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_min_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_max_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_max_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_max_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_step_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_step_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_step_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_step_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->step = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_step_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_step_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->step);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_trigger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_trigger_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_trigger_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_trigger_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->trigger = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_trigger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_trigger_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->trigger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_reset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_reset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_reset_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_reset_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->reset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_reset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_reset_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->reset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_output_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_output_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_syncOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCounter_syncOut_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_syncOut_set" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCounter_syncOut_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->syncOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCounter_syncOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCounter_syncOut_get" "', argument " "1"" of type '" "SoCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoCounter * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->syncOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCounter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCounter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCounter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFTime", 0, 0, 0)) SWIG_fail;
  result = (SoSFTime *)new SoSFTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFTime" "', argument " "1"" of type '" "SoSFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFTime::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFTime::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_getTypeId" "', argument " "1"" of type '" "SoSFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  result = ((SoSFTime const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_copyFrom" "', argument " "1"" of type '" "SoSFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTime_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTime_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_isSame" "', argument " "1"" of type '" "SoSFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTime_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTime_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFTime const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_getValue" "', argument " "1"" of type '" "SoSFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  result = (SbTime *) &((SoSFTime const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_setValue" "', argument " "1"" of type '" "SoSFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime___eq__" "', argument " "1"" of type '" "SoSFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTime___eq__" "', argument " "2"" of type '" "SoSFTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTime___eq__" "', argument " "2"" of type '" "SoSFTime const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  result = (int)((SoSFTime const *)arg1)->operator ==((SoSFTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFTime___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime___ne__" "', argument " "1"" of type '" "SoSFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTime___ne__" "', argument " "2"" of type '" "SoSFTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFTime___ne__" "', argument " "2"" of type '" "SoSFTime const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  result = (int)((SoSFTime const *)arg1)->operator !=((SoSFTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFTime_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFTime_initClass", 0, 0, 0)) SWIG_fail;
  SoSFTime::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_setValue" "', argument " "1"" of type '" "SoSFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  SoSFTime_setValue__SWIG_1(arg1,*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFTime *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFTime_setValue" "', argument " "1"" of type '" "SoSFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoSFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFTime_setValue" "', argument " "2"" of type '" "SoSFTime const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  SoSFTime_setValue__SWIG_2(arg1,(SoSFTime const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFTime_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFTime_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFTime, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFTime_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSFTime_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoSFTime_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFTime_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFTime::setValue(SbTime const &)\n"
    "    SoSFTime::setValue(SbTime &)\n"
    "    SoSFTime::setValue(SoSFTime const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoElapsedTime_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoElapsedTime::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_getTypeId" "', argument " "1"" of type '" "SoElapsedTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = ((SoElapsedTime const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_getFieldData" "', argument " "1"" of type '" "SoElapsedTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoFieldData *)((SoElapsedTime const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_getOutputData" "', argument " "1"" of type '" "SoElapsedTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoEngineOutputData *)((SoElapsedTime const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoElapsedTime::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_initClass", 0, 0, 0)) SWIG_fail;
  SoElapsedTime::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoElapsedTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoElapsedTime", 0, 0, 0)) SWIG_fail;
  result = (SoElapsedTime *)new SoElapsedTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElapsedTime, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_timeIn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_timeIn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_timeIn_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_timeIn_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->timeIn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_timeIn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_timeIn_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoSFTime *)& ((arg1)->timeIn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_speed_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_speed_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_on_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_on_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_pause_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_pause_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_pause_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_pause_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->pause = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_pause_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_pause_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoSFBool *)& ((arg1)->pause);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_reset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_reset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_reset_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_reset_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->reset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_reset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_reset_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->reset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_timeOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoElapsedTime_timeOut_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_timeOut_set" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoElapsedTime_timeOut_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->timeOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoElapsedTime_timeOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoElapsedTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoElapsedTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoElapsedTime_timeOut_get" "', argument " "1"" of type '" "SoElapsedTime *""'"); 
  }
  arg1 = reinterpret_cast< SoElapsedTime * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->timeOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoElapsedTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoElapsedTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoElapsedTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFieldConverter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFieldConverter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getTypeId" "', argument " "1"" of type '" "SoFieldConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  result = ((SoFieldConverter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getFieldData" "', argument " "1"" of type '" "SoFieldConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  result = (SoFieldData *)((SoFieldConverter const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getOutputData" "', argument " "1"" of type '" "SoFieldConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  result = (SoEngineOutputData *)((SoFieldConverter const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_initClass", 0, 0, 0)) SWIG_fail;
  SoFieldConverter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_initClasses", 0, 0, 0)) SWIG_fail;
  SoFieldConverter::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_getInput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getInput" "', argument " "1"" of type '" "SoFieldConverter *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldConverter_getInput" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldConverter_getInput" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SoField *)(arg1)->getInput(SWIG_STD_MOVE(arg2));
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_getOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getOutput" "', argument " "1"" of type '" "SoFieldConverter *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldConverter_getOutput" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldConverter_getOutput" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SoEngineOutput *)(arg1)->getOutput(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getConnectedInput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getConnectedInput" "', argument " "1"" of type '" "SoFieldConverter *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  result = (SoField *)(arg1)->getConnectedInput();
  {
    resultobj = autocast_field(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFieldConverter_getForwardConnections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFieldConverter *arg1 = 0 ;
  SoFieldList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFieldConverter_getForwardConnections", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFieldConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFieldConverter_getForwardConnections" "', argument " "1"" of type '" "SoFieldConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SoFieldConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoFieldList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFieldConverter_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoFieldConverter_getForwardConnections" "', argument " "2"" of type '" "SoFieldList &""'"); 
  }
  arg2 = reinterpret_cast< SoFieldList * >(argp2);
  result = (int)((SoFieldConverter const *)arg1)->getForwardConnections(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFieldConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFieldConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoGate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_getTypeId" "', argument " "1"" of type '" "SoGate const *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = ((SoGate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_getFieldData" "', argument " "1"" of type '" "SoGate const *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoFieldData *)((SoGate const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_getOutputData" "', argument " "1"" of type '" "SoGate const *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoEngineOutputData *)((SoGate const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoGate::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_initClass", 0, 0, 0)) SWIG_fail;
  SoGate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGate *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoGate" "', argument " "1"" of type '" "SoType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoGate" "', argument " "1"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (SoGate *)new SoGate(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_enable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_enable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_enable_set" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGate_enable_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enable = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_enable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_enable_get" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoSFBool *)& ((arg1)->enable);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_trigger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_trigger_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_trigger_set" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGate_trigger_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->trigger = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_trigger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_trigger_get" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->trigger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_input_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  SoMField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_input_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_input_set" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGate_input_set" "', argument " "2"" of type '" "SoMField *""'"); 
  }
  arg2 = reinterpret_cast< SoMField * >(argp2);
  if (arg1) (arg1)->input = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_input_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_input_get" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoMField *) ((arg1)->input);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMField, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGate_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_output_set" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGate_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGate_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGate_output_get" "', argument " "1"" of type '" "SoGate *""'"); 
  }
  arg1 = reinterpret_cast< SoGate * >(argp1);
  result = (SoEngineOutput *) ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInterpolate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_getTypeId" "', argument " "1"" of type '" "SoInterpolate const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  result = ((SoInterpolate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_getFieldData" "', argument " "1"" of type '" "SoInterpolate const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  result = (SoFieldData *)((SoInterpolate const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_getOutputData" "', argument " "1"" of type '" "SoInterpolate const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolate const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolate_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolate_initClasses", 0, 0, 0)) SWIG_fail;
  SoInterpolate::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolate_alpha_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_alpha_set" "', argument " "1"" of type '" "SoInterpolate *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolate_alpha_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->alpha = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_alpha_get" "', argument " "1"" of type '" "SoInterpolate *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  result = (SoSFFloat *)& ((arg1)->alpha);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolate_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_output_set" "', argument " "1"" of type '" "SoInterpolate *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolate_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolate_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolate_output_get" "', argument " "1"" of type '" "SoInterpolate *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolate * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoInterpolateFloat_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateFloat_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolateFloat::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_getTypeId" "', argument " "1"" of type '" "SoInterpolateFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  result = ((SoInterpolateFloat const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_getFieldData" "', argument " "1"" of type '" "SoInterpolateFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  result = (SoFieldData *)((SoInterpolateFloat const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_getOutputData" "', argument " "1"" of type '" "SoInterpolateFloat const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolateFloat const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateFloat_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoInterpolateFloat::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInterpolateFloat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInterpolateFloat", 0, 0, 0)) SWIG_fail;
  result = (SoInterpolateFloat *)new SoInterpolateFloat();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInterpolateFloat, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateFloat_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolateFloat::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateFloat_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_input0_set" "', argument " "1"" of type '" "SoInterpolateFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateFloat_input0_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_input0_get" "', argument " "1"" of type '" "SoInterpolateFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  result = (SoMFFloat *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateFloat_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_input1_set" "', argument " "1"" of type '" "SoInterpolateFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateFloat_input1_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateFloat_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateFloat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateFloat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateFloat_input1_get" "', argument " "1"" of type '" "SoInterpolateFloat *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateFloat * >(argp1);
  result = (SoMFFloat *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolateFloat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolateFloat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInterpolateFloat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolateVec2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_getTypeId" "', argument " "1"" of type '" "SoInterpolateVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  result = ((SoInterpolateVec2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_getFieldData" "', argument " "1"" of type '" "SoInterpolateVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  result = (SoFieldData *)((SoInterpolateVec2f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_getOutputData" "', argument " "1"" of type '" "SoInterpolateVec2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolateVec2f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoInterpolateVec2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInterpolateVec2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInterpolateVec2f", 0, 0, 0)) SWIG_fail;
  result = (SoInterpolateVec2f *)new SoInterpolateVec2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInterpolateVec2f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec2f_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolateVec2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec2f_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_input0_set" "', argument " "1"" of type '" "SoInterpolateVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec2f_input0_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_input0_get" "', argument " "1"" of type '" "SoInterpolateVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec2f_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_input1_set" "', argument " "1"" of type '" "SoInterpolateVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec2f_input1_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec2f_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec2f_input1_get" "', argument " "1"" of type '" "SoInterpolateVec2f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec2f * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolateVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolateVec2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInterpolateVec2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolateVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_getTypeId" "', argument " "1"" of type '" "SoInterpolateVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  result = ((SoInterpolateVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_getFieldData" "', argument " "1"" of type '" "SoInterpolateVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  result = (SoFieldData *)((SoInterpolateVec3f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_getOutputData" "', argument " "1"" of type '" "SoInterpolateVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolateVec3f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoInterpolateVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInterpolateVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInterpolateVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoInterpolateVec3f *)new SoInterpolateVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInterpolateVec3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolateVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec3f_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_input0_set" "', argument " "1"" of type '" "SoInterpolateVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec3f_input0_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_input0_get" "', argument " "1"" of type '" "SoInterpolateVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec3f_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_input1_set" "', argument " "1"" of type '" "SoInterpolateVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec3f_input1_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec3f_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec3f_input1_get" "', argument " "1"" of type '" "SoInterpolateVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec3f * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolateVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolateVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInterpolateVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolateVec4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_getTypeId" "', argument " "1"" of type '" "SoInterpolateVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  result = ((SoInterpolateVec4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_getFieldData" "', argument " "1"" of type '" "SoInterpolateVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  result = (SoFieldData *)((SoInterpolateVec4f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_getOutputData" "', argument " "1"" of type '" "SoInterpolateVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolateVec4f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec4f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoInterpolateVec4f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInterpolateVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInterpolateVec4f", 0, 0, 0)) SWIG_fail;
  result = (SoInterpolateVec4f *)new SoInterpolateVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInterpolateVec4f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec4f_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolateVec4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec4f_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_input0_set" "', argument " "1"" of type '" "SoInterpolateVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec4f_input0_set" "', argument " "2"" of type '" "SoMFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_input0_get" "', argument " "1"" of type '" "SoInterpolateVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  result = (SoMFVec4f *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateVec4f_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_input1_set" "', argument " "1"" of type '" "SoInterpolateVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateVec4f_input1_set" "', argument " "2"" of type '" "SoMFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateVec4f_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateVec4f_input1_get" "', argument " "1"" of type '" "SoInterpolateVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateVec4f * >(argp1);
  result = (SoMFVec4f *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolateVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolateVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInterpolateVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInterpolateRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInterpolateRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_getTypeId" "', argument " "1"" of type '" "SoInterpolateRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  result = ((SoInterpolateRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_getFieldData" "', argument " "1"" of type '" "SoInterpolateRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  result = (SoFieldData *)((SoInterpolateRotation const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_getOutputData" "', argument " "1"" of type '" "SoInterpolateRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  result = (SoEngineOutputData *)((SoInterpolateRotation const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateRotation_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoInterpolateRotation::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInterpolateRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInterpolateRotation", 0, 0, 0)) SWIG_fail;
  result = (SoInterpolateRotation *)new SoInterpolateRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInterpolateRotation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoInterpolateRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateRotation_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_input0_set" "', argument " "1"" of type '" "SoInterpolateRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateRotation_input0_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_input0_get" "', argument " "1"" of type '" "SoInterpolateRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  result = (SoMFRotation *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInterpolateRotation_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_input1_set" "', argument " "1"" of type '" "SoInterpolateRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInterpolateRotation_input1_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInterpolateRotation_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInterpolateRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInterpolateRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInterpolateRotation_input1_get" "', argument " "1"" of type '" "SoInterpolateRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoInterpolateRotation * >(argp1);
  result = (SoMFRotation *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInterpolateRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInterpolateRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInterpolateRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoOnOff_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoOnOff::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_getTypeId" "', argument " "1"" of type '" "SoOnOff const *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = ((SoOnOff const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_getFieldData" "', argument " "1"" of type '" "SoOnOff const *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoFieldData *)((SoOnOff const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_getOutputData" "', argument " "1"" of type '" "SoOnOff const *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoEngineOutputData *)((SoOnOff const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoOnOff::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_initClass", 0, 0, 0)) SWIG_fail;
  SoOnOff::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOnOff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoOnOff", 0, 0, 0)) SWIG_fail;
  result = (SoOnOff *)new SoOnOff();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOnOff, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_on_set" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOnOff_on_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_on_get" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_off_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_off_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_off_set" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOnOff_off_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->off = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_off_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_off_get" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->off);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_toggle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_toggle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_toggle_set" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOnOff_toggle_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->toggle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_toggle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_toggle_get" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->toggle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_isOn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_isOn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_isOn_set" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOnOff_isOn_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->isOn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_isOn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_isOn_get" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->isOn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_isOff_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOnOff_isOff_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_isOff_set" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOnOff_isOff_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->isOff = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOnOff_isOff_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOnOff *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOnOff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOnOff_isOff_get" "', argument " "1"" of type '" "SoOnOff *""'"); 
  }
  arg1 = reinterpret_cast< SoOnOff * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->isOff);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOnOff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOnOff, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOnOff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBitMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBitMask", 0, 0, 0)) SWIG_fail;
  result = (SoSFBitMask *)new SoSFBitMask();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBitMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBitMask *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBitMask, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBitMask" "', argument " "1"" of type '" "SoSFBitMask *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBitMask * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBitMask_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBitMask::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBitMask_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBitMask::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBitMask *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBitMask_getTypeId" "', argument " "1"" of type '" "SoSFBitMask const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBitMask * >(argp1);
  result = ((SoSFBitMask const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBitMask *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBitMask_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBitMask_copyFrom" "', argument " "1"" of type '" "SoSFBitMask *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBitMask * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBitMask_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBitMask_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBitMask *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBitMask_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBitMask_isSame" "', argument " "1"" of type '" "SoSFBitMask const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBitMask * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBitMask_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBitMask_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBitMask const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBitMask_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBitMask_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBitMask::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSFBitMask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBitMask, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBitMask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoOneShot_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoOneShot::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_getTypeId" "', argument " "1"" of type '" "SoOneShot const *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = ((SoOneShot const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_getFieldData" "', argument " "1"" of type '" "SoOneShot const *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoFieldData *)((SoOneShot const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_getOutputData" "', argument " "1"" of type '" "SoOneShot const *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoEngineOutputData *)((SoOneShot const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoOneShot::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_initClass", 0, 0, 0)) SWIG_fail;
  SoOneShot::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOneShot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoOneShot", 0, 0, 0)) SWIG_fail;
  result = (SoOneShot *)new SoOneShot();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOneShot, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_timeIn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_timeIn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_timeIn_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_timeIn_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->timeIn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_timeIn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_timeIn_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoSFTime *)& ((arg1)->timeIn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_duration_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_duration_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_duration_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_duration_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->duration = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_duration_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_duration_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoSFTime *)& ((arg1)->duration);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_trigger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_trigger_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_trigger_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_trigger_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->trigger = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_trigger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_trigger_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->trigger);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_flags_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_flags_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_flags_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_flags_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->flags = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_flags_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_flags_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->flags);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_disable_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_disable_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_disable_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_disable_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->disable = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_disable_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_disable_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoSFBool *)& ((arg1)->disable);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_timeOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_timeOut_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_timeOut_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_timeOut_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->timeOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_timeOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_timeOut_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->timeOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_isActive_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_isActive_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_isActive_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_ramp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOneShot_ramp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_ramp_set" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOneShot_ramp_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->ramp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOneShot_ramp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShot *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOneShot_ramp_get" "', argument " "1"" of type '" "SoOneShot *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShot * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->ramp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOneShot_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOneShot, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOneShot_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSelectOne_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSelectOne::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_getTypeId" "', argument " "1"" of type '" "SoSelectOne const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = ((SoSelectOne const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_getFieldData" "', argument " "1"" of type '" "SoSelectOne const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = (SoFieldData *)((SoSelectOne const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_getOutputData" "', argument " "1"" of type '" "SoSelectOne const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = (SoEngineOutputData *)((SoSelectOne const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSelectOne::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_index_set" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelectOne_index_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->index = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_index_get" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->index);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_input_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  SoMField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_input_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_input_set" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelectOne_input_set" "', argument " "2"" of type '" "SoMField *""'"); 
  }
  arg2 = reinterpret_cast< SoMField * >(argp2);
  if (arg1) (arg1)->input = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_input_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_input_get" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = (SoMField *) ((arg1)->input);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMField, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_output_set" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelectOne_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelectOne *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelectOne, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelectOne_output_get" "', argument " "1"" of type '" "SoSelectOne *""'"); 
  }
  arg1 = reinterpret_cast< SoSelectOne * >(argp1);
  result = (SoEngineOutput *) ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSelectOne(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSelectOne *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoSelectOne" "', argument " "1"" of type '" "SoType""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoSelectOne" "', argument " "1"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (SoSelectOne *)new SoSelectOne(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSelectOne, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelectOne_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelectOne_initClass", 0, 0, 0)) SWIG_fail;
  SoSelectOne::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSelectOne_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSelectOne, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSelectOne_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTimeCounter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTimeCounter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_getTypeId" "', argument " "1"" of type '" "SoTimeCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = ((SoTimeCounter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_getFieldData" "', argument " "1"" of type '" "SoTimeCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoFieldData *)((SoTimeCounter const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_getOutputData" "', argument " "1"" of type '" "SoTimeCounter const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoEngineOutputData *)((SoTimeCounter const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTimeCounter::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_timeIn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_timeIn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_timeIn_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_timeIn_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->timeIn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_timeIn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_timeIn_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFTime *)& ((arg1)->timeIn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_min_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_min_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_min_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->min = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_min_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_min_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->min);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_max_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_max_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->max = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_max_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->max);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_step_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_step_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_step_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_step_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->step = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_step_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_step_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->step);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_on_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_on_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_frequency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_frequency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_frequency_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_frequency_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->frequency = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_frequency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_frequency_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFFloat *)& ((arg1)->frequency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_duty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_duty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_duty_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_duty_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->duty = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_duty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_duty_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoMFFloat *)& ((arg1)->duty);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_reset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_reset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_reset_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_reset_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->reset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_reset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_reset_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFShort *)& ((arg1)->reset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_syncIn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_syncIn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_syncIn_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_syncIn_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->syncIn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_syncIn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_syncIn_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->syncIn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_output_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_output_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_syncOut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_syncOut_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_syncOut_set" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTimeCounter_syncOut_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->syncOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_syncOut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimeCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimeCounter_syncOut_get" "', argument " "1"" of type '" "SoTimeCounter *""'"); 
  }
  arg1 = reinterpret_cast< SoTimeCounter * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->syncOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTimeCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimeCounter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTimeCounter", 0, 0, 0)) SWIG_fail;
  result = (SoTimeCounter *)new SoTimeCounter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTimeCounter, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimeCounter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimeCounter_initClass", 0, 0, 0)) SWIG_fail;
  SoTimeCounter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTimeCounter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTimeCounter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTimeCounter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformVec3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformVec3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_getTypeId" "', argument " "1"" of type '" "SoTransformVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = ((SoTransformVec3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_getFieldData" "', argument " "1"" of type '" "SoTransformVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoFieldData *)((SoTransformVec3f const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_getOutputData" "', argument " "1"" of type '" "SoTransformVec3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoEngineOutputData *)((SoTransformVec3f const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTransformVec3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformVec3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformVec3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformVec3f", 0, 0, 0)) SWIG_fail;
  result = (SoTransformVec3f *)new SoTransformVec3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformVec3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_vector_set" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformVec3f_vector_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_vector_get" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_matrix_set" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformVec3f_matrix_set" "', argument " "2"" of type '" "SoMFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_matrix_get" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoMFMatrix *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_point_set" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformVec3f_point_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_point_get" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_direction_set" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformVec3f_direction_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_direction_get" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_normalDirection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformVec3f_normalDirection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_normalDirection_set" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformVec3f_normalDirection_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->normalDirection = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformVec3f_normalDirection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformVec3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformVec3f_normalDirection_get" "', argument " "1"" of type '" "SoTransformVec3f *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformVec3f * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->normalDirection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformVec3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformVec3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTriggerAny_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTriggerAny::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_getTypeId" "', argument " "1"" of type '" "SoTriggerAny const *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = ((SoTriggerAny const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_getFieldData" "', argument " "1"" of type '" "SoTriggerAny const *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoFieldData *)((SoTriggerAny const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_getOutputData" "', argument " "1"" of type '" "SoTriggerAny const *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoEngineOutputData *)((SoTriggerAny const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoTriggerAny::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_initClass", 0, 0, 0)) SWIG_fail;
  SoTriggerAny::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTriggerAny(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTriggerAny", 0, 0, 0)) SWIG_fail;
  result = (SoTriggerAny *)new SoTriggerAny();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTriggerAny, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input0_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input0_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input0_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input1_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input1_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input1_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input2_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input2_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input2_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input3_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input3_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input3_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input4_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input4_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input4_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input4_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input4_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input4_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input5_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input5_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input5 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input5_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input6_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input6_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input6_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input6_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input6 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input6_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input6_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input7_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input7_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input7_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input7_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input7 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input7_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input7_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input8_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input8_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input8_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input8_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input8 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input8_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input8_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input9_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoSFTrigger *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_input9_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input9_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_input9_set" "', argument " "2"" of type '" "SoSFTrigger *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTrigger * >(argp2);
  if (arg1) (arg1)->input9 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_input9_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTrigger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_input9_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoSFTrigger *)& ((arg1)->input9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTrigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_output_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriggerAny_output_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_output_set" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriggerAny_output_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->output = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriggerAny_output_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriggerAny *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriggerAny, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriggerAny_output_get" "', argument " "1"" of type '" "SoTriggerAny *""'"); 
  }
  arg1 = reinterpret_cast< SoTriggerAny * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->output);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTriggerAny_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTriggerAny, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTriggerAny_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTexture2Convert_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Convert_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture2Convert::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_getTypeId" "', argument " "1"" of type '" "SoTexture2Convert const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  result = ((SoTexture2Convert const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_getFieldData" "', argument " "1"" of type '" "SoTexture2Convert const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  result = (SoFieldData *)((SoTexture2Convert const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_getOutputData" "', argument " "1"" of type '" "SoTexture2Convert const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  result = (SoEngineOutputData *)((SoTexture2Convert const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Convert_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture2Convert::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_sourceImage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Convert_sourceImage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_sourceImage_set" "', argument " "1"" of type '" "SoTexture2Convert *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Convert_sourceImage_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->sourceImage = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_sourceImage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_sourceImage_get" "', argument " "1"" of type '" "SoTexture2Convert *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  result = (SoSFImage *)& ((arg1)->sourceImage);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Convert_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_image_set" "', argument " "1"" of type '" "SoTexture2Convert *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Convert_image_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->image = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Convert_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Convert_image_get" "', argument " "1"" of type '" "SoTexture2Convert *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->image);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTexture2Convert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Convert *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Convert, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTexture2Convert" "', argument " "1"" of type '" "SoTexture2Convert *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Convert * >(argp1);
  arg1->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTexture2Convert_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture2Convert, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHeightMapToNormalMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoHeightMapToNormalMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_getTypeId" "', argument " "1"" of type '" "SoHeightMapToNormalMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  result = ((SoHeightMapToNormalMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_getFieldData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoFieldData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_getFieldData" "', argument " "1"" of type '" "SoHeightMapToNormalMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  result = (SoFieldData *)((SoHeightMapToNormalMap const *)arg1)->getFieldData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFieldData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_getOutputData" "', argument " "1"" of type '" "SoHeightMapToNormalMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  result = (SoEngineOutputData *)((SoHeightMapToNormalMap const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHeightMapToNormalMap_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoHeightMapToNormalMap::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHeightMapToNormalMap_initClass", 0, 0, 0)) SWIG_fail;
  SoHeightMapToNormalMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoHeightMapToNormalMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoHeightMapToNormalMap", 0, 0, 0)) SWIG_fail;
  result = (SoHeightMapToNormalMap *)new SoHeightMapToNormalMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHeightMapToNormalMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHeightMapToNormalMap_format_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_format_set" "', argument " "1"" of type '" "SoHeightMapToNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHeightMapToNormalMap_format_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->format = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_format_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_format_get" "', argument " "1"" of type '" "SoHeightMapToNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->format);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHeightMapToNormalMap_convert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = 0 ;
  SbVec2s arg2 ;
  int arg3 ;
  SbImage *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHeightMapToNormalMap_convert", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHeightMapToNormalMap_convert" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoHeightMapToNormalMap_convert" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoHeightMapToNormalMap_convert" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoHeightMapToNormalMap_convert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbImage,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoHeightMapToNormalMap_convert" "', argument " "4"" of type '" "SbImage &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoHeightMapToNormalMap_convert" "', argument " "4"" of type '" "SbImage &""'"); 
  }
  arg4 = reinterpret_cast< SbImage * >(argp4);
  SoHeightMapToNormalMap::convert((unsigned char const *)arg1,SWIG_STD_MOVE(arg2),arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoHeightMapToNormalMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHeightMapToNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHeightMapToNormalMap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoHeightMapToNormalMap" "', argument " "1"" of type '" "SoHeightMapToNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoHeightMapToNormalMap * >(argp1);
  arg1->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoHeightMapToNormalMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoHeightMapToNormalMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoHeightMapToNormalMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodeEngine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_initClass", 0, 0, 0)) SWIG_fail;
  SoNodeEngine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNodeEngine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_evaluateWrapper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_evaluateWrapper" "', argument " "1"" of type '" "SoNodeEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  (arg1)->evaluateWrapper();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_getOutputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  SoEngineOutputList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_getOutputs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_getOutputs" "', argument " "1"" of type '" "SoNodeEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoEngineOutputList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeEngine_getOutputs" "', argument " "2"" of type '" "SoEngineOutputList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNodeEngine_getOutputs" "', argument " "2"" of type '" "SoEngineOutputList &""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutputList * >(argp2);
  result = (int)((SoNodeEngine const *)arg1)->getOutputs(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_getOutput", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_getOutput" "', argument " "1"" of type '" "SoNodeEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoEngineOutput *)((SoNodeEngine const *)arg1)->getOutput((SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_getOutputName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_getOutputName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_getOutputName" "', argument " "1"" of type '" "SoNodeEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeEngine_getOutputName" "', argument " "2"" of type '" "SoEngineOutput const *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)((SoNodeEngine const *)arg1)->getOutputName((SoEngineOutput const *)arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_getOutputData" "', argument " "1"" of type '" "SoNodeEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  result = (SoEngineOutputData *)((SoNodeEngine const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_isNotifying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_isNotifying" "', argument " "1"" of type '" "SoNodeEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  result = (SbBool)((SoNodeEngine const *)arg1)->isNotifying();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_notify" "', argument " "1"" of type '" "SoNodeEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeEngine_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeEngine_writeInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeEngine *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeEngine_writeInstance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeEngine_writeInstance" "', argument " "1"" of type '" "SoNodeEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeEngine_writeInstance" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->writeInstance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeEngine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoMemoryError_setHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *arg1 = (SoErrorCB *)0 ;
  void *arg2 = (void *)0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMemoryError_setHandlerCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoMemoryError_setHandlerCallback" "', argument " "1"" of type '" "SoErrorCB *const""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  SoMemoryError::setHandlerCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_getHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMemoryError_getHandlerCallback", 0, 0, 0)) SWIG_fail;
  result = (SoErrorCB *)SoMemoryError::getHandlerCallback();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_getHandlerData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMemoryError_getHandlerData", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMemoryError::getHandlerData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMemoryError_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMemoryError::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMemoryError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMemoryError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMemoryError_getTypeId" "', argument " "1"" of type '" "SoMemoryError const *""'"); 
  }
  arg1 = reinterpret_cast< SoMemoryError * >(argp1);
  result = ((SoMemoryError const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_post(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMemoryError_post" "', argument " "1"" of type '" "char const *const""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoMemoryError::post((char const *)arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMemoryError_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMemoryError_initClass", 0, 0, 0)) SWIG_fail;
  SoMemoryError::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMemoryError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMemoryError *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMemoryError", 0, 0, 0)) SWIG_fail;
  result = (SoMemoryError *)new SoMemoryError();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMemoryError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMemoryError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMemoryError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMemoryError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMemoryError" "', argument " "1"" of type '" "SoMemoryError *""'"); 
  }
  arg1 = reinterpret_cast< SoMemoryError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMemoryError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMemoryError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMemoryError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoReadError_setHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *arg1 = (SoErrorCB *)0 ;
  void *arg2 = (void *)0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReadError_setHandlerCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoReadError_setHandlerCallback" "', argument " "1"" of type '" "SoErrorCB *const""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  SoReadError::setHandlerCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_getHandlerCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoErrorCB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReadError_getHandlerCallback", 0, 0, 0)) SWIG_fail;
  result = (SoErrorCB *)SoReadError::getHandlerCallback();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__SoError_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_getHandlerData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReadError_getHandlerData", 0, 0, 0)) SWIG_fail;
  result = (void *)SoReadError::getHandlerData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReadError_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoReadError::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReadError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReadError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReadError_getTypeId" "', argument " "1"" of type '" "SoReadError const *""'"); 
  }
  arg1 = reinterpret_cast< SoReadError * >(argp1);
  result = ((SoReadError const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_post__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  SoInput *arg1 = (SoInput *)0 ;
  char *arg2 = (char *)0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SoReadError_post", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReadError_post" "', argument " "1"" of type '" "SoInput const *const""'"); 
  }
  arg1 = reinterpret_cast< SoInput * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoReadError_post" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  SoReadError::post((SoInput const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReadError_post(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SoReadError_post__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SoReadError_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReadError_initClass", 0, 0, 0)) SWIG_fail;
  SoReadError::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoReadError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReadError *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoReadError", 0, 0, 0)) SWIG_fail;
  result = (SoReadError *)new SoReadError();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoReadError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoReadError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReadError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReadError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoReadError" "', argument " "1"" of type '" "SoReadError *""'"); 
  }
  arg1 = reinterpret_cast< SoReadError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoReadError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoReadError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoReadError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoButtonEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoButtonEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoButtonEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoButtonEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoButtonEvent_getTypeId" "', argument " "1"" of type '" "SoButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoButtonEvent * >(argp1);
  result = ((SoButtonEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoButtonEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoButtonEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoButtonEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoButtonEvent", 0, 0, 0)) SWIG_fail;
  result = (SoButtonEvent *)new SoButtonEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoButtonEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoButtonEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoButtonEvent" "', argument " "1"" of type '" "SoButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoButtonEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoButtonEvent_setState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent *arg1 = 0 ;
  SoButtonEvent::State arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoButtonEvent_setState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoButtonEvent_setState" "', argument " "1"" of type '" "SoButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoButtonEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoButtonEvent_setState" "', argument " "2"" of type '" "SoButtonEvent::State""'");
  } 
  arg2 = static_cast< SoButtonEvent::State >(val2);
  (arg1)->setState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoButtonEvent_getState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoButtonEvent::State result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoButtonEvent_getState" "', argument " "1"" of type '" "SoButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoButtonEvent * >(argp1);
  result = (SoButtonEvent::State)((SoButtonEvent const *)arg1)->getState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoButtonEvent_enumToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoButtonEvent::State arg1 ;
  SbString *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoButtonEvent_enumToString", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoButtonEvent_enumToString" "', argument " "1"" of type '" "SoButtonEvent::State""'");
  } 
  arg1 = static_cast< SoButtonEvent::State >(val1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)SoButtonEvent::enumToString(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoButtonEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoButtonEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoButtonEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLocation2Event_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocation2Event_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLocation2Event::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocation2Event_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocation2Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocation2Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocation2Event_getTypeId" "', argument " "1"" of type '" "SoLocation2Event const *""'"); 
  }
  arg1 = reinterpret_cast< SoLocation2Event * >(argp1);
  result = ((SoLocation2Event const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocation2Event_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocation2Event_initClass", 0, 0, 0)) SWIG_fail;
  SoLocation2Event::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLocation2Event(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocation2Event *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLocation2Event", 0, 0, 0)) SWIG_fail;
  result = (SoLocation2Event *)new SoLocation2Event();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLocation2Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoLocation2Event(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocation2Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocation2Event, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoLocation2Event" "', argument " "1"" of type '" "SoLocation2Event *""'"); 
  }
  arg1 = reinterpret_cast< SoLocation2Event * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLocation2Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLocation2Event, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLocation2Event_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMotion3Event_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMotion3Event_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMotion3Event::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMotion3Event_getTypeId" "', argument " "1"" of type '" "SoMotion3Event const *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  result = ((SoMotion3Event const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMotion3Event_initClass", 0, 0, 0)) SWIG_fail;
  SoMotion3Event::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMotion3Event(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMotion3Event", 0, 0, 0)) SWIG_fail;
  result = (SoMotion3Event *)new SoMotion3Event();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMotion3Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMotion3Event(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMotion3Event" "', argument " "1"" of type '" "SoMotion3Event *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_setTranslation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMotion3Event_setTranslation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMotion3Event_setTranslation" "', argument " "1"" of type '" "SoMotion3Event *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMotion3Event_setTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMotion3Event_setTranslation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setTranslation((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_getTranslation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMotion3Event_getTranslation" "', argument " "1"" of type '" "SoMotion3Event const *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  result = (SbVec3f *) &((SoMotion3Event const *)arg1)->getTranslation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_setRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMotion3Event_setRotation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMotion3Event_setRotation" "', argument " "1"" of type '" "SoMotion3Event *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMotion3Event_setRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMotion3Event_setRotation" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  (arg1)->setRotation((SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMotion3Event_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMotion3Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMotion3Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMotion3Event_getRotation" "', argument " "1"" of type '" "SoMotion3Event const *""'"); 
  }
  arg1 = reinterpret_cast< SoMotion3Event * >(argp1);
  result = (SbRotation *) &((SoMotion3Event const *)arg1)->getRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMotion3Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMotion3Event, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMotion3Event_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoKeyboardEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoKeyboardEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_getTypeId" "', argument " "1"" of type '" "SoKeyboardEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  result = ((SoKeyboardEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoKeyboardEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoKeyboardEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoKeyboardEvent", 0, 0, 0)) SWIG_fail;
  result = (SoKeyboardEvent *)new SoKeyboardEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoKeyboardEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoKeyboardEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoKeyboardEvent" "', argument " "1"" of type '" "SoKeyboardEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_setKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  SoKeyboardEvent::Key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_setKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_setKey" "', argument " "1"" of type '" "SoKeyboardEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoKeyboardEvent_setKey" "', argument " "2"" of type '" "SoKeyboardEvent::Key""'");
  } 
  arg2 = static_cast< SoKeyboardEvent::Key >(val2);
  (arg1)->setKey(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_getKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoKeyboardEvent::Key result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_getKey" "', argument " "1"" of type '" "SoKeyboardEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  result = (SoKeyboardEvent::Key)((SoKeyboardEvent const *)arg1)->getKey();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_setPrintableCharacter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_setPrintableCharacter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_setPrintableCharacter" "', argument " "1"" of type '" "SoKeyboardEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoKeyboardEvent_setPrintableCharacter" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->setPrintableCharacter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_getPrintableCharacter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoKeyboardEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_getPrintableCharacter" "', argument " "1"" of type '" "SoKeyboardEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoKeyboardEvent * >(argp1);
  result = (char)((SoKeyboardEvent const *)arg1)->getPrintableCharacter();
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_isKeyPressEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoKeyboardEvent::Key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_isKeyPressEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_isKeyPressEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoKeyboardEvent_isKeyPressEvent" "', argument " "2"" of type '" "SoKeyboardEvent::Key""'");
  } 
  arg2 = static_cast< SoKeyboardEvent::Key >(val2);
  result = (SbBool)SoKeyboardEvent::isKeyPressEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_isKeyReleaseEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoKeyboardEvent::Key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_isKeyReleaseEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoKeyboardEvent_isKeyReleaseEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoKeyboardEvent_isKeyReleaseEvent" "', argument " "2"" of type '" "SoKeyboardEvent::Key""'");
  } 
  arg2 = static_cast< SoKeyboardEvent::Key >(val2);
  result = (SbBool)SoKeyboardEvent::isKeyReleaseEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoKeyboardEvent_enumToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoKeyboardEvent::Key arg1 ;
  SbString *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoKeyboardEvent_enumToString", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoKeyboardEvent_enumToString" "', argument " "1"" of type '" "SoKeyboardEvent::Key""'");
  } 
  arg1 = static_cast< SoKeyboardEvent::Key >(val1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)SoKeyboardEvent::enumToString(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoKeyboardEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoKeyboardEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoKeyboardEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMouseButtonEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMouseButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMouseButtonEvent_getTypeId" "', argument " "1"" of type '" "SoMouseButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoMouseButtonEvent * >(argp1);
  result = ((SoMouseButtonEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoMouseButtonEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMouseButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMouseButtonEvent", 0, 0, 0)) SWIG_fail;
  result = (SoMouseButtonEvent *)new SoMouseButtonEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMouseButtonEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMouseButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMouseButtonEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMouseButtonEvent" "', argument " "1"" of type '" "SoMouseButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoMouseButtonEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_setButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent *arg1 = 0 ;
  SoMouseButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_setButton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMouseButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMouseButtonEvent_setButton" "', argument " "1"" of type '" "SoMouseButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoMouseButtonEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMouseButtonEvent_setButton" "', argument " "2"" of type '" "SoMouseButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoMouseButtonEvent::Button >(val2);
  (arg1)->setButton(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_getButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMouseButtonEvent::Button result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMouseButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMouseButtonEvent_getButton" "', argument " "1"" of type '" "SoMouseButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoMouseButtonEvent * >(argp1);
  result = (SoMouseButtonEvent::Button)((SoMouseButtonEvent const *)arg1)->getButton();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_isButtonPressEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoMouseButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_isButtonPressEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMouseButtonEvent_isButtonPressEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMouseButtonEvent_isButtonPressEvent" "', argument " "2"" of type '" "SoMouseButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoMouseButtonEvent::Button >(val2);
  result = (SbBool)SoMouseButtonEvent::isButtonPressEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_isButtonReleaseEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoMouseButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_isButtonReleaseEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMouseButtonEvent_isButtonReleaseEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMouseButtonEvent_isButtonReleaseEvent" "', argument " "2"" of type '" "SoMouseButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoMouseButtonEvent::Button >(val2);
  result = (SbBool)SoMouseButtonEvent::isButtonReleaseEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMouseButtonEvent_enumToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMouseButtonEvent::Button arg1 ;
  SbString *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMouseButtonEvent_enumToString", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMouseButtonEvent_enumToString" "', argument " "1"" of type '" "SoMouseButtonEvent::Button""'");
  } 
  arg1 = static_cast< SoMouseButtonEvent::Button >(val1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)SoMouseButtonEvent::enumToString(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoMouseButtonEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMouseButtonEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMouseButtonEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSpaceballButtonEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpaceballButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpaceballButtonEvent_getTypeId" "', argument " "1"" of type '" "SoSpaceballButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpaceballButtonEvent * >(argp1);
  result = ((SoSpaceballButtonEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoSpaceballButtonEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSpaceballButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSpaceballButtonEvent", 0, 0, 0)) SWIG_fail;
  result = (SoSpaceballButtonEvent *)new SoSpaceballButtonEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSpaceballButtonEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSpaceballButtonEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpaceballButtonEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSpaceballButtonEvent" "', argument " "1"" of type '" "SoSpaceballButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoSpaceballButtonEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_setButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent *arg1 = 0 ;
  SoSpaceballButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_setButton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpaceballButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpaceballButtonEvent_setButton" "', argument " "1"" of type '" "SoSpaceballButtonEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoSpaceballButtonEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSpaceballButtonEvent_setButton" "', argument " "2"" of type '" "SoSpaceballButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoSpaceballButtonEvent::Button >(val2);
  (arg1)->setButton(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_getButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSpaceballButtonEvent::Button result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpaceballButtonEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpaceballButtonEvent_getButton" "', argument " "1"" of type '" "SoSpaceballButtonEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpaceballButtonEvent * >(argp1);
  result = (SoSpaceballButtonEvent::Button)((SoSpaceballButtonEvent const *)arg1)->getButton();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_isButtonPressEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoSpaceballButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_isButtonPressEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpaceballButtonEvent_isButtonPressEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSpaceballButtonEvent_isButtonPressEvent" "', argument " "2"" of type '" "SoSpaceballButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoSpaceballButtonEvent::Button >(val2);
  result = (SbBool)SoSpaceballButtonEvent::isButtonPressEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_isButtonReleaseEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEvent *arg1 = 0 ;
  SoSpaceballButtonEvent::Button arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_isButtonReleaseEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpaceballButtonEvent_isButtonReleaseEvent" "', argument " "1"" of type '" "SoEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSpaceballButtonEvent_isButtonReleaseEvent" "', argument " "2"" of type '" "SoSpaceballButtonEvent::Button""'");
  } 
  arg2 = static_cast< SoSpaceballButtonEvent::Button >(val2);
  result = (SbBool)SoSpaceballButtonEvent::isButtonReleaseEvent((SoEvent const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpaceballButtonEvent_enumToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpaceballButtonEvent::Button arg1 ;
  SbString *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpaceballButtonEvent_enumToString", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoSpaceballButtonEvent_enumToString" "', argument " "1"" of type '" "SoSpaceballButtonEvent::Button""'");
  } 
  arg1 = static_cast< SoSpaceballButtonEvent::Button >(val1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)SoSpaceballButtonEvent::enumToString(arg1,*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoSpaceballButtonEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSpaceballButtonEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSpaceballButtonEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox2s *)new SbBox2s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox2s" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox2s" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox2s" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox2s" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  result = (SbBox2s *)new SbBox2s(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox2s" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2s" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbBox2s *)new SbBox2s((SbVec2s const &)*arg1,(SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbBox2s *)new SbBox2s((SbBox2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbBox2s *)new SbBox2s((SbBox2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2s" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbBox2s *)new SbBox2s((SbBox2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2s(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox2s", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox2s__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2s__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2s__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2s__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox2s__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbBox2s__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox2s'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::SbBox2s()\n"
    "    SbBox2s::SbBox2s(short,short,short,short)\n"
    "    SbBox2s::SbBox2s(SbVec2s const &,SbVec2s const &)\n"
    "    SbBox2s::SbBox2s(SbBox2i32 const &)\n"
    "    SbBox2s::SbBox2s(SbBox2f const &)\n"
    "    SbBox2s::SbBox2s(SbBox2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_setBounds" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox2s_setBounds" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox2s_setBounds" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox2s_setBounds" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  result = (SbBox2s *) &(arg1)->setBounds(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_setBounds" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2s_setBounds" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_setBounds" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  result = (SbBox2s *) &(arg1)->setBounds((SbVec2s const &)*arg2,(SbVec2s const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_setBounds" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  result = (SbBox2s *) &(arg1)->setBounds((SbBox2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_setBounds" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (SbBox2s *) &(arg1)->setBounds((SbBox2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_setBounds" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (SbBox2s *) &(arg1)->setBounds((SbBox2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_setBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2s_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbBox2s_setBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::setBounds(short,short,short,short)\n"
    "    SbBox2s::setBounds(SbVec2s const &,SbVec2s const &)\n"
    "    SbBox2s::setBounds(SbBox2i32 const &)\n"
    "    SbBox2s::setBounds(SbBox2f const &)\n"
    "    SbBox2s::setBounds(SbBox2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  short *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getBounds" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_getBounds" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2s_getBounds" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox2s_getBounds" "', argument " "4"" of type '" "short &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "4"" of type '" "short &""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox2s_getBounds" "', argument " "5"" of type '" "short &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "5"" of type '" "short &""'"); 
  }
  arg5 = reinterpret_cast< short * >(argp5);
  ((SbBox2s const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getBounds" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_getBounds" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2s_getBounds" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getBounds" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ((SbBox2s const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_getBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2s_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbBox2s_getBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::getBounds(short &,short &,short &,short &) const\n"
    "    SbBox2s::getBounds(SbVec2s &,SbVec2s &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getMin" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbVec2s *) &((SbBox2s const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getMin" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbVec2s *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2s_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2s_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::getMin() const\n"
    "    SbBox2s::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getMax" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbVec2s *) &((SbBox2s const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getMax" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbVec2s *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2s_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2s_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::getMax() const\n"
    "    SbBox2s::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_extendBy" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_extendBy" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_extendBy" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->extendBy((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_extendBy" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_extendBy" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_extendBy" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  (arg1)->extendBy((SbBox2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::extendBy(SbVec2s const &)\n"
    "    SbBox2s::extendBy(SbBox2s const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_makeEmpty" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_isEmpty" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbBool)((SbBox2s const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_hasArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_hasArea" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbBool)((SbBox2s const *)arg1)->hasArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_intersect" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_intersect" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_intersect" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbBool)((SbBox2s const *)arg1)->intersect((SbVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_intersect" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_intersect" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_intersect" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (SbBool)((SbBox2s const *)arg1)->intersect((SbBox2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2s_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::intersect(SbVec2s const &) const\n"
    "    SbBox2s::intersect(SbBox2s const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getCenter" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = ((SbBox2s const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2s_getOrigin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getOrigin" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_getOrigin" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getOrigin" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2s_getOrigin" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getOrigin" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  ((SbBox2s const *)arg1)->getOrigin(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getSize" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s_getSize" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getSize" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2s_getSize" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s_getSize" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  ((SbBox2s const *)arg1)->getSize(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2s result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getSize" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = ((SbBox2s const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2s_getSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2s_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2s_getSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2s_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2s::getSize(short &,short &) const\n"
    "    SbBox2s::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2s_getAspectRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s_getAspectRatio" "', argument " "1"" of type '" "SbBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (float)((SbBox2s const *)arg1)->getAspectRatio();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s___eq__" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s___eq__" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s___eq__" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (int)SbBox2s___eq__(arg1,(SbBox2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox2s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2s___ne__" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2s___ne__" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2s___ne__" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (int)SbBox2s___ne__(arg1,(SbBox2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbBox2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox2s" "', argument " "1"" of type '" "SbBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox2s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox2s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox2s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox2s", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox2s *)new SoSFBox2s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox2s" "', argument " "1"" of type '" "SoSFBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox2s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox2s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_getTypeId" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  result = ((SoSFBox2s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_copyFrom" "', argument " "1"" of type '" "SoSFBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_isSame" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox2s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_getValue" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  result = (SbBox2s *) &((SoSFBox2s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_setValue" "', argument " "1"" of type '" "SoSFBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s_setValue" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_setValue" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  (arg1)->setValue((SbBox2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SoSFBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s___eq__" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s___eq__" "', argument " "2"" of type '" "SoSFBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s___eq__" "', argument " "2"" of type '" "SoSFBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2s * >(argp2);
  result = (int)((SoSFBox2s const *)arg1)->operator ==((SoSFBox2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SoSFBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s___ne__" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s___ne__" "', argument " "2"" of type '" "SoSFBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s___ne__" "', argument " "2"" of type '" "SoSFBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2s * >(argp2);
  result = (int)((SoSFBox2s const *)arg1)->operator !=((SoSFBox2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2s_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox2s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_setValue" "', argument " "1"" of type '" "SoSFBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox2s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox2s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox2s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox2s_setValue" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SbVec2s arg2 ;
  SbVec2s arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_setValue" "', argument " "1"" of type '" "SoSFBox2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s_setValue" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_setValue" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox2s_setValue" "', argument " "3"" of type '" "SbVec2s""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_setValue" "', argument " "3"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2s_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox2s_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFBox2s_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2s::setValue(SbBox2s const &)\n"
    "    SoSFBox2s::setValue(short,short,short,short)\n"
    "    SoSFBox2s::setValue(SbVec2s,SbVec2s)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2s *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2s_getValue" "', argument " "1"" of type '" "SoSFBox2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2s_getValue" "', argument " "2"" of type '" "SbBox2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2s_getValue" "', argument " "2"" of type '" "SbBox2s &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  ((SoSFBox2s const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2s_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2s_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox2s_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2s_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2s_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2s::getValue() const\n"
    "    SoSFBox2s::getValue(SbBox2s &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox2s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox2s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox2s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec2i32 *)new SbVec2i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t *arg1 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "int32_t const [2]""'"); 
  } 
  arg1 = reinterpret_cast< int32_t * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((int32_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec2i32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (SbVec2i32 *)new SbVec2i32(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2ui32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2ui32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2ui32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2ui32 * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((SbVec2ui32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((SbVec2b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((SbVec2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((SbVec2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2i32" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (SbVec2i32 *)new SbVec2i32((SbVec2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2i32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec2i32", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec2i32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2ui32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2i32__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbVec2i32__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec2i32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2i32::SbVec2i32()\n"
    "    SbVec2i32::SbVec2i32(int32_t const [2])\n"
    "    SbVec2i32::SbVec2i32(int32_t,int32_t)\n"
    "    SbVec2i32::SbVec2i32(SbVec2ui32 const &)\n"
    "    SbVec2i32::SbVec2i32(SbVec2b const &)\n"
    "    SbVec2i32::SbVec2i32(SbVec2s const &)\n"
    "    SbVec2i32::SbVec2i32(SbVec2f const &)\n"
    "    SbVec2i32::SbVec2i32(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "int32_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  result = (SbVec2i32 *) &(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2ui32 * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((SbVec2ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2b * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((SbVec2b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_setValue" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2i32 *) &(arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2i32_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2i32_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbVec2i32_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2i32::setValue(int32_t const [2])\n"
    "    SbVec2i32::setValue(int32_t,int32_t)\n"
    "    SbVec2i32::setValue(SbVec2ui32 const &)\n"
    "    SbVec2i32::setValue(SbVec2b const &)\n"
    "    SbVec2i32::setValue(SbVec2s const &)\n"
    "    SbVec2i32::setValue(SbVec2f const &)\n"
    "    SbVec2i32::setValue(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_getValue" "', argument " "1"" of type '" "SbVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = (int32_t *)((SbVec2i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_getValue" "', argument " "1"" of type '" "SbVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec2i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  ((SbVec2i32 const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2i32_getValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec2i32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbVec2i32_getValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2i32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2i32::getValue() const\n"
    "    SbVec2i32::getValue(int32_t &,int32_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2i32_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_dot" "', argument " "1"" of type '" "SbVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32_dot" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32_dot" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (int32_t)((SbVec2i32 const *)arg1)->dot((SbVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_negate" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___imul__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2i32___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___imul__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2i32___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2i32___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2i32___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2i32___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2i32___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2i32::operator *=(int)\n"
    "    SbVec2i32::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___itruediv__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2i32___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___itruediv__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2i32___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2i32___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2i32___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2i32___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2i32___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2i32::operator /=(int)\n"
    "    SbVec2i32::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2i32___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___iadd__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32___iadd__" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32___iadd__" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2i32 *) &(arg1)->operator +=((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2i32___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___isub__" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2i32___isub__" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2i32___isub__" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2i32 *) &(arg1)->operator -=((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2i32___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2i32 result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32___neg__" "', argument " "1"" of type '" "SbVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = ((SbVec2i32 const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec2i32(result)), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2i32_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2i32_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2i32_output" "', argument " "1"" of type '" "SbVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec2i32 const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec2i32" "', argument " "1"" of type '" "SbVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec2i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec2i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec2i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox2i32 *)new SbBox2i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox2i32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox2i32" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox2i32" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  result = (SbBox2i32 *)new SbBox2i32(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox2i32" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2i32" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbBox2i32 *)new SbBox2i32((SbVec2i32 const &)*arg1,(SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbBox2i32 *)new SbBox2i32((SbBox2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbBox2i32 *)new SbBox2i32((SbBox2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2i32" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbBox2i32 *)new SbBox2i32((SbBox2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2i32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox2i32", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox2i32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2i32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2i32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2i32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox2i32__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbBox2i32__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox2i32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::SbBox2i32()\n"
    "    SbBox2i32::SbBox2i32(int32_t,int32_t,int32_t,int32_t)\n"
    "    SbBox2i32::SbBox2i32(SbVec2i32 const &,SbVec2i32 const &)\n"
    "    SbBox2i32::SbBox2i32(SbBox2s const &)\n"
    "    SbBox2i32::SbBox2i32(SbBox2f const &)\n"
    "    SbBox2i32::SbBox2i32(SbBox2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_setBounds" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox2i32_setBounds" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox2i32_setBounds" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox2i32_setBounds" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  result = (SbBox2i32 *) &(arg1)->setBounds(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_setBounds" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2i32_setBounds" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_setBounds" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  result = (SbBox2i32 *) &(arg1)->setBounds((SbVec2i32 const &)*arg2,(SbVec2i32 const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_setBounds" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (SbBox2i32 *) &(arg1)->setBounds((SbBox2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_setBounds" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (SbBox2i32 *) &(arg1)->setBounds((SbBox2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_setBounds" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (SbBox2i32 *) &(arg1)->setBounds((SbBox2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_setBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2i32_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbBox2i32_setBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::setBounds(int32_t,int32_t,int32_t,int32_t)\n"
    "    SbBox2i32::setBounds(SbVec2i32 const &,SbVec2i32 const &)\n"
    "    SbBox2i32::setBounds(SbBox2s const &)\n"
    "    SbBox2i32::setBounds(SbBox2f const &)\n"
    "    SbBox2i32::setBounds(SbBox2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  int32_t *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getBounds" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_getBounds" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2i32_getBounds" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox2i32_getBounds" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox2i32_getBounds" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  arg5 = reinterpret_cast< int32_t * >(argp5);
  ((SbBox2i32 const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getBounds" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_getBounds" "', argument " "2"" of type '" "SbVec2i32 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "2"" of type '" "SbVec2i32 &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2i32,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2i32_getBounds" "', argument " "3"" of type '" "SbVec2i32 &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getBounds" "', argument " "3"" of type '" "SbVec2i32 &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  ((SbBox2i32 const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_getBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2i32_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbBox2i32_getBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::getBounds(int32_t &,int32_t &,int32_t &,int32_t &) const\n"
    "    SbBox2i32::getBounds(SbVec2i32 &,SbVec2i32 &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getMin" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbVec2i32 *) &((SbBox2i32 const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getMin" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbVec2i32 *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2i32_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2i32_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::getMin() const\n"
    "    SbBox2i32::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getMax" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbVec2i32 *) &((SbBox2i32 const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getMax" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbVec2i32 *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2i32_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2i32_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::getMax() const\n"
    "    SbBox2i32::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_extendBy" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_extendBy" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_extendBy" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  (arg1)->extendBy((SbVec2i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_extendBy" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_extendBy" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_extendBy" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  (arg1)->extendBy((SbBox2i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::extendBy(SbVec2i32 const &)\n"
    "    SbBox2i32::extendBy(SbBox2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_makeEmpty" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_isEmpty" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbBool)((SbBox2i32 const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_hasArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_hasArea" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbBool)((SbBox2i32 const *)arg1)->hasArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_intersect" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_intersect" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_intersect" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbBool)((SbBox2i32 const *)arg1)->intersect((SbVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_intersect" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_intersect" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_intersect" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  result = (SbBool)((SbBox2i32 const *)arg1)->intersect((SbBox2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2i32_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::intersect(SbVec2i32 const &) const\n"
    "    SbBox2i32::intersect(SbBox2i32 const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getCenter" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = ((SbBox2i32 const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2i32_getOrigin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getOrigin" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_getOrigin" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getOrigin" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2i32_getOrigin" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getOrigin" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  ((SbBox2i32 const *)arg1)->getOrigin(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getSize" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2i32_getSize" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getSize" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2i32_getSize" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2i32_getSize" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  ((SbBox2i32 const *)arg1)->getSize(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2i32 result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getSize" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = ((SbBox2i32 const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec2i32(result)), SWIGTYPE_p_SbVec2i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2i32_getSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2i32_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2i32_getSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2i32_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2i32::getSize(int32_t &,int32_t &) const\n"
    "    SbBox2i32::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2i32_getAspectRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2i32_getAspectRatio" "', argument " "1"" of type '" "SbBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (float)((SbBox2i32 const *)arg1)->getAspectRatio();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbBox2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox2i32" "', argument " "1"" of type '" "SbBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox2i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox2i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox2i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox2i32", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox2i32 *)new SoSFBox2i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox2i32" "', argument " "1"" of type '" "SoSFBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox2i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox2i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_getTypeId" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  result = ((SoSFBox2i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_copyFrom" "', argument " "1"" of type '" "SoSFBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_isSame" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox2i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_getValue" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  result = (SbBox2i32 *) &((SoSFBox2i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_setValue" "', argument " "1"" of type '" "SoSFBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32_setValue" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_setValue" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  (arg1)->setValue((SbBox2i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SoSFBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32___eq__" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32___eq__" "', argument " "2"" of type '" "SoSFBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32___eq__" "', argument " "2"" of type '" "SoSFBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2i32 * >(argp2);
  result = (int)((SoSFBox2i32 const *)arg1)->operator ==((SoSFBox2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SoSFBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32___ne__" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32___ne__" "', argument " "2"" of type '" "SoSFBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32___ne__" "', argument " "2"" of type '" "SoSFBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2i32 * >(argp2);
  result = (int)((SoSFBox2i32 const *)arg1)->operator !=((SoSFBox2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2i32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox2i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_setValue" "', argument " "1"" of type '" "SoSFBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox2i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox2i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox2i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox2i32_setValue" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_setValue" "', argument " "1"" of type '" "SoSFBox2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox2i32_setValue" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_setValue" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  (arg1)->setValue((SbVec2i32 const &)*arg2,(SbVec2i32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2i32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox2i32_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFBox2i32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2i32::setValue(SbBox2i32 const &)\n"
    "    SoSFBox2i32::setValue(int32_t,int32_t,int32_t,int32_t)\n"
    "    SoSFBox2i32::setValue(SbVec2i32 const &,SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2i32 *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2i32_getValue" "', argument " "1"" of type '" "SoSFBox2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2i32_getValue" "', argument " "2"" of type '" "SbBox2i32 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2i32_getValue" "', argument " "2"" of type '" "SbBox2i32 &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  ((SoSFBox2i32 const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2i32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2i32_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox2i32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2i32_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2i32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2i32::getValue() const\n"
    "    SoSFBox2i32::getValue(SbBox2i32 &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox2i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox2i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox2i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox2f *)new SbBox2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox2f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox2f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox2f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox2f" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SbBox2f *)new SbBox2f(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox2f" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2f" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbBox2f *)new SbBox2f((SbVec2f const &)*arg1,(SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbBox2f *)new SbBox2f((SbBox2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbBox2f *)new SbBox2f((SbBox2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2f" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbBox2f *)new SbBox2f((SbBox2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2f(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox2f", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox2f__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2f__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2f__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2f__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox2f__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbBox2f__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox2f'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::SbBox2f()\n"
    "    SbBox2f::SbBox2f(float,float,float,float)\n"
    "    SbBox2f::SbBox2f(SbVec2f const &,SbVec2f const &)\n"
    "    SbBox2f::SbBox2f(SbBox2d const &)\n"
    "    SbBox2f::SbBox2f(SbBox2s const &)\n"
    "    SbBox2f::SbBox2f(SbBox2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_setBounds" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox2f_setBounds" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox2f_setBounds" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox2f_setBounds" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  result = (SbBox2f *) &(arg1)->setBounds(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_setBounds" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2f_setBounds" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_setBounds" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (SbBox2f *) &(arg1)->setBounds((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_setBounds" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (SbBox2f *) &(arg1)->setBounds((SbBox2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_setBounds" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (SbBox2f *) &(arg1)->setBounds((SbBox2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_setBounds" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  result = (SbBox2f *) &(arg1)->setBounds((SbBox2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_setBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2f_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbBox2f_setBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::setBounds(float,float,float,float)\n"
    "    SbBox2f::setBounds(SbVec2f const &,SbVec2f const &)\n"
    "    SbBox2f::setBounds(SbBox2d const &)\n"
    "    SbBox2f::setBounds(SbBox2s const &)\n"
    "    SbBox2f::setBounds(SbBox2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getBounds" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_getBounds" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2f_getBounds" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox2f_getBounds" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox2f_getBounds" "', argument " "5"" of type '" "float &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "5"" of type '" "float &""'"); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  ((SbBox2f const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getBounds" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_getBounds" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2f_getBounds" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getBounds" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  ((SbBox2f const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_getBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2f_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbBox2f_getBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::getBounds(float &,float &,float &,float &) const\n"
    "    SbBox2f::getBounds(SbVec2f &,SbVec2f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getMin" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbVec2f *) &((SbBox2f const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getMin" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbVec2f *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2f_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2f_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::getMin() const\n"
    "    SbBox2f::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getMax" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbVec2f *) &((SbBox2f const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getMax" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbVec2f *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2f_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2f_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::getMax() const\n"
    "    SbBox2f::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_extendBy" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_extendBy" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_extendBy" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->extendBy((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_extendBy" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_extendBy" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_extendBy" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  (arg1)->extendBy((SbBox2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::extendBy(SbVec2f const &)\n"
    "    SbBox2f::extendBy(SbBox2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_makeEmpty" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_isEmpty" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbBool)((SbBox2f const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_hasArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_hasArea" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbBool)((SbBox2f const *)arg1)->hasArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_intersect" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_intersect" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_intersect" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbBool)((SbBox2f const *)arg1)->intersect((SbVec2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_intersect" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_intersect" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_intersect" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (SbBool)((SbBox2f const *)arg1)->intersect((SbBox2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2f_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::intersect(SbVec2f const &) const\n"
    "    SbBox2f::intersect(SbBox2f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2f_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getClosestPoint" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_getClosestPoint" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getClosestPoint" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = ((SbBox2f const *)arg1)->getClosestPoint((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getCenter" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = ((SbBox2f const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2f_getOrigin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getOrigin" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_getOrigin" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getOrigin" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2f_getOrigin" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getOrigin" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ((SbBox2f const *)arg1)->getOrigin(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getSize" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f_getSize" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getSize" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2f_getSize" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f_getSize" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ((SbBox2f const *)arg1)->getSize(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getSize" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = ((SbBox2f const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec2f(result)), SWIGTYPE_p_SbVec2f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2f_getSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2f_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2f_getSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2f_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2f::getSize(float &,float &) const\n"
    "    SbBox2f::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2f_getAspectRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f_getAspectRatio" "', argument " "1"" of type '" "SbBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (float)((SbBox2f const *)arg1)->getAspectRatio();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f___eq__" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f___eq__" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f___eq__" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (int)SbBox2f___eq__(arg1,(SbBox2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox2f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2f___ne__" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2f___ne__" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2f___ne__" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (int)SbBox2f___ne__(arg1,(SbBox2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbBox2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox2f" "', argument " "1"" of type '" "SbBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox2f", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox2f *)new SoSFBox2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox2f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox2f" "', argument " "1"" of type '" "SoSFBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox2f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_getTypeId" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  result = ((SoSFBox2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_copyFrom" "', argument " "1"" of type '" "SoSFBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_isSame" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox2f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_getValue" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  result = (SbBox2f *) &((SoSFBox2f const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_setValue" "', argument " "1"" of type '" "SoSFBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f_setValue" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_setValue" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  (arg1)->setValue((SbBox2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SoSFBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f___eq__" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f___eq__" "', argument " "2"" of type '" "SoSFBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f___eq__" "', argument " "2"" of type '" "SoSFBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2f * >(argp2);
  result = (int)((SoSFBox2f const *)arg1)->operator ==((SoSFBox2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SoSFBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f___ne__" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f___ne__" "', argument " "2"" of type '" "SoSFBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f___ne__" "', argument " "2"" of type '" "SoSFBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2f * >(argp2);
  result = (int)((SoSFBox2f const *)arg1)->operator !=((SoSFBox2f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2f_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_setValue" "', argument " "1"" of type '" "SoSFBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox2f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox2f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox2f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox2f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_setValue" "', argument " "1"" of type '" "SoSFBox2f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox2f_setValue" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_setValue" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  (arg1)->setValue((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox2f_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFBox2f_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2f::setValue(SbBox2f const &)\n"
    "    SoSFBox2f::setValue(float,float,float,float)\n"
    "    SoSFBox2f::setValue(SbVec2f const &,SbVec2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2f *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2f_getValue" "', argument " "1"" of type '" "SoSFBox2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2f_getValue" "', argument " "2"" of type '" "SbBox2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2f_getValue" "', argument " "2"" of type '" "SbBox2f &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  ((SoSFBox2f const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2f_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2f_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox2f_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2f_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2f_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2f::getValue() const\n"
    "    SoSFBox2f::getValue(SbBox2f &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec2d *)new SbVec2d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = (double *)0 ;
  double temp1[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec2d_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec2d *)new SbVec2d((double const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec2d" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec2d" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2d *)new SbVec2d(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (SbVec2d *)new SbVec2d((SbVec2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = (SbVec2d *)new SbVec2d((SbVec2b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = (SbVec2d *)new SbVec2d((SbVec2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2d" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = (SbVec2d *)new SbVec2d((SbVec2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec2d", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec2d__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2d__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2d__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2d__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2d__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbVec2d__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbVec2d__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec2d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2d::SbVec2d()\n"
    "    SbVec2d::SbVec2d(double const [2])\n"
    "    SbVec2d::SbVec2d(double,double)\n"
    "    SbVec2d::SbVec2d(SbVec2f const &)\n"
    "    SbVec2d::SbVec2d(SbVec2b const &)\n"
    "    SbVec2d::SbVec2d(SbVec2s const &)\n"
    "    SbVec2d::SbVec2d(SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  {
    convert_SbVec2d_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec2d *) &(arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbVec2d *) &(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2d *) &(arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2b * >(argp2);
  result = (SbVec2d *) &(arg1)->setValue((SbVec2b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbVec2d *) &(arg1)->setValue((SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_setValue" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2d *) &(arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2d_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2d_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2d_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2d_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbVec2d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbVec2d_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2d::setValue(double const [2])\n"
    "    SbVec2d::setValue(double,double)\n"
    "    SbVec2d::setValue(SbVec2f const &)\n"
    "    SbVec2d::setValue(SbVec2b const &)\n"
    "    SbVec2d::setValue(SbVec2s const &)\n"
    "    SbVec2d::setValue(SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  int res2 = SWIG_TMPOBJ ;
  double temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_getValue" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ((SbVec2d const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_equals" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_equals" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_equals" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2d_equals" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbBool)((SbVec2d const *)arg1)->equals((SbVec2d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_dot" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d_dot" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d_dot" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (double)((SbVec2d const *)arg1)->dot((SbVec2d const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_length" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (double)((SbVec2d const *)arg1)->length();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_sqrLength" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (double)((SbVec2d const *)arg1)->sqrLength();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_normalize" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (double)(arg1)->normalize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_negate" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___imul__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2d *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___itruediv__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2d *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___iadd__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___iadd__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___iadd__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2d *) &(arg1)->operator +=((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___isub__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___isub__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___isub__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2d *) &(arg1)->operator -=((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___neg__" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = ((SbVec2d const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d_output" "', argument " "1"" of type '" "SbVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec2d const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___add__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___add__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___add__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = SbVec2d___add__(arg1,(SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___sub__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___sub__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___sub__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = SbVec2d___sub__(arg1,(SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___mul__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___mul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2d___mul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___rmul__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___rmul__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2d___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___div__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___div__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2d___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___truediv__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___truediv__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = SbVec2d___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___eq__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___eq__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___eq__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (int)SbVec2d___eq__(arg1,(SbVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec2d___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___nq__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2d___nq__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2d___nq__" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (int)SbVec2d___nq__(arg1,(SbVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___getitem__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)SbVec2d___getitem__(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2d___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2d___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2d___setitem__" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2d___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2d___setitem__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  SbVec2d___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec2d" "', argument " "1"" of type '" "SbVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec2d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec2d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox2d *)new SbBox2d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox2d" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox2d" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox2d" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox2d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (SbBox2d *)new SbBox2d(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox2d" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2d" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbBox2d *)new SbBox2d((SbVec2d const &)*arg1,(SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2f * >(argp1);
  result = (SbBox2d *)new SbBox2d((SbBox2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2s * >(argp1);
  result = (SbBox2d *)new SbBox2d((SbBox2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox2d" "', argument " "1"" of type '" "SbBox2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox2i32 * >(argp1);
  result = (SbBox2d *)new SbBox2d((SbBox2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox2d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox2d", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox2d__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2d__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2d__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox2d__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox2d__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbBox2d__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox2d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::SbBox2d()\n"
    "    SbBox2d::SbBox2d(double,double,double,double)\n"
    "    SbBox2d::SbBox2d(SbVec2d const &,SbVec2d const &)\n"
    "    SbBox2d::SbBox2d(SbBox2f const &)\n"
    "    SbBox2d::SbBox2d(SbBox2s const &)\n"
    "    SbBox2d::SbBox2d(SbBox2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setBounds" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox2d_setBounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox2d_setBounds" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox2d_setBounds" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (SbBox2d *) &(arg1)->setBounds(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setBounds" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_setBounds" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setBounds" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  result = (SbBox2d *) &(arg1)->setBounds((SbVec2d const &)*arg2,(SbVec2d const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setBounds" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2f * >(argp2);
  result = (SbBox2d *) &(arg1)->setBounds((SbBox2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setBounds" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2s * >(argp2);
  result = (SbBox2d *) &(arg1)->setBounds((SbBox2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setBounds" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setBounds" "', argument " "2"" of type '" "SbBox2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2i32 * >(argp2);
  result = (SbBox2d *) &(arg1)->setBounds((SbBox2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_setBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2d_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbBox2d_setBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::setBounds(double,double,double,double)\n"
    "    SbBox2d::setBounds(SbVec2d const &,SbVec2d const &)\n"
    "    SbBox2d::setBounds(SbBox2f const &)\n"
    "    SbBox2d::setBounds(SbBox2s const &)\n"
    "    SbBox2d::setBounds(SbBox2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getBounds" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_getBounds" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_getBounds" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox2d_getBounds" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox2d_getBounds" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  ((SbBox2d const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getBounds" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_getBounds" "', argument " "2"" of type '" "SbVec2d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "2"" of type '" "SbVec2d &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_getBounds" "', argument " "3"" of type '" "SbVec2d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getBounds" "', argument " "3"" of type '" "SbVec2d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  ((SbBox2d const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_getBounds", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2d_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbBox2d_getBounds__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::getBounds(double &,double &,double &,double &) const\n"
    "    SbBox2d::getBounds(SbVec2d &,SbVec2d &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getMin" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbVec2d *) &((SbBox2d const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getMin" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbVec2d *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2d_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2d_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::getMin() const\n"
    "    SbBox2d::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getMax" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbVec2d *) &((SbBox2d const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getMax" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbVec2d *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2d_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2d_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::getMax() const\n"
    "    SbBox2d::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_extendBy" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_extendBy" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_extendBy" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  (arg1)->extendBy((SbVec2d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_extendBy" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_extendBy" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_extendBy" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  (arg1)->extendBy((SbBox2d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::extendBy(SbVec2d const &)\n"
    "    SbBox2d::extendBy(SbBox2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_makeEmpty" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_isEmpty" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbBool)((SbBox2d const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_hasArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_hasArea" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (SbBool)((SbBox2d const *)arg1)->hasArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_intersect" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_intersect" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_intersect" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbBool)((SbBox2d const *)arg1)->intersect((SbVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_intersect" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_intersect" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_intersect" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (SbBool)((SbBox2d const *)arg1)->intersect((SbBox2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox2d_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::intersect(SbVec2d const &) const\n"
    "    SbBox2d::intersect(SbBox2d const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getClosestPoint" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_getClosestPoint" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getClosestPoint" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = ((SbBox2d const *)arg1)->getClosestPoint((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_findIntersection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbVec2d *arg3 = 0 ;
  SbVec2d *arg4 = 0 ;
  SbVec2d *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d_findIntersection", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_findIntersection" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_findIntersection" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_findIntersection" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_findIntersection" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_findIntersection" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox2d_findIntersection" "', argument " "4"" of type '" "SbVec2d &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_findIntersection" "', argument " "4"" of type '" "SbVec2d &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2d,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox2d_findIntersection" "', argument " "5"" of type '" "SbVec2d &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_findIntersection" "', argument " "5"" of type '" "SbVec2d &""'"); 
  }
  arg5 = reinterpret_cast< SbVec2d * >(argp5);
  result = (SbBool)((SbBox2d const *)arg1)->findIntersection((SbVec2d const &)*arg2,(SbVec2d const &)*arg3,*arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getCenter" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = ((SbBox2d const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d_getOrigin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getOrigin" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_getOrigin" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getOrigin" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_getOrigin" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getOrigin" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ((SbBox2d const *)arg1)->getOrigin(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getSize" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_getSize" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getSize" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox2d_getSize" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_getSize" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ((SbBox2d const *)arg1)->getSize(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2d result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getSize" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = ((SbBox2d const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec2d(result)), SWIGTYPE_p_SbVec2d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox2d_getSize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox2d_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox2d_getSize__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox2d_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox2d::getSize(double &,double &) const\n"
    "    SbBox2d::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox2d_getAspectRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_getAspectRatio" "', argument " "1"" of type '" "SbBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  result = (double)((SbBox2d const *)arg1)->getAspectRatio();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox2d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d___eq__" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d___eq__" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d___eq__" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (int)SbBox2d___eq__(arg1,(SbBox2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox2d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d___ne__" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d___ne__" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d___ne__" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (int)SbBox2d___ne__(arg1,(SbBox2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox2d_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox2d_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox2d_setValue" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox2d_setValue" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox2d_setValue" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  result = (SbBox2d *) &SbBox2d_setValue(arg1,(SbBox2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbBox2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox2d" "', argument " "1"" of type '" "SbBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox2d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox2d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox2d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox2d", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox2d *)new SoSFBox2d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox2d" "', argument " "1"" of type '" "SoSFBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox2d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox2d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_getTypeId" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  result = ((SoSFBox2d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_copyFrom" "', argument " "1"" of type '" "SoSFBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_isSame" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox2d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox2d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_getValue" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  result = (SbBox2d *) &((SoSFBox2d const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_setValue" "', argument " "1"" of type '" "SoSFBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d_setValue" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_setValue" "', argument " "2"" of type '" "SbBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  (arg1)->setValue((SbBox2d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SoSFBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d___eq__" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d___eq__" "', argument " "2"" of type '" "SoSFBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d___eq__" "', argument " "2"" of type '" "SoSFBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2d * >(argp2);
  result = (int)((SoSFBox2d const *)arg1)->operator ==((SoSFBox2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SoSFBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d___ne__" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d___ne__" "', argument " "2"" of type '" "SoSFBox2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d___ne__" "', argument " "2"" of type '" "SoSFBox2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox2d * >(argp2);
  result = (int)((SoSFBox2d const *)arg1)->operator !=((SoSFBox2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox2d_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox2d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_setValue" "', argument " "1"" of type '" "SoSFBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox2d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox2d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox2d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox2d_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_setValue" "', argument " "1"" of type '" "SoSFBox2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox2d_setValue" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_setValue" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  (arg1)->setValue((SbVec2d const &)*arg2,(SbVec2d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2d_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox2d_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFBox2d_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2d::setValue(SbBox2d const &)\n"
    "    SoSFBox2d::setValue(double,double,double,double)\n"
    "    SoSFBox2d::setValue(SbVec2d const &,SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox2d *arg1 = 0 ;
  SbBox2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox2d_getValue" "', argument " "1"" of type '" "SoSFBox2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox2d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox2d_getValue" "', argument " "2"" of type '" "SbBox2d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox2d_getValue" "', argument " "2"" of type '" "SbBox2d &""'"); 
  }
  arg2 = reinterpret_cast< SbBox2d * >(argp2);
  ((SoSFBox2d const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox2d_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox2d_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox2d_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox2d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox2d_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox2d_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox2d::getValue() const\n"
    "    SoSFBox2d::getValue(SbBox2d &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox2d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox2d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox3s *)new SbBox3s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  short arg6 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox3s" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox3s" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox3s" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox3s" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbBox3s" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbBox3s" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  result = (SbBox3s *)new SbBox3s(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox3s" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3s" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbBox3s *)new SbBox3s((SbVec3s const &)*arg1,(SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbBox3s *)new SbBox3s((SbBox3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbBox3s *)new SbBox3s((SbBox3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3s" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbBox3s *)new SbBox3s((SbBox3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3s(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox3s", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox3s__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3s__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3s__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3s__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox3s__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SbBox3s__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox3s'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::SbBox3s()\n"
    "    SbBox3s::SbBox3s(short,short,short,short,short,short)\n"
    "    SbBox3s::SbBox3s(SbVec3s const &,SbVec3s const &)\n"
    "    SbBox3s::SbBox3s(SbBox3i32 const &)\n"
    "    SbBox3s::SbBox3s(SbBox3f const &)\n"
    "    SbBox3s::SbBox3s(SbBox3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  short arg6 ;
  short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  short val7 ;
  int ecode7 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_setBounds" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox3s_setBounds" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox3s_setBounds" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox3s_setBounds" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbBox3s_setBounds" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  ecode7 = SWIG_AsVal_short(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbBox3s_setBounds" "', argument " "7"" of type '" "short""'");
  } 
  arg7 = static_cast< short >(val7);
  result = (SbBox3s *) &(arg1)->setBounds(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_setBounds" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3s_setBounds" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_setBounds" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  result = (SbBox3s *) &(arg1)->setBounds((SbVec3s const &)*arg2,(SbVec3s const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_setBounds" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  result = (SbBox3s *) &(arg1)->setBounds((SbBox3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_setBounds" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBox3s *) &(arg1)->setBounds((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_setBounds" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  result = (SbBox3s *) &(arg1)->setBounds((SbBox3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_setBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3s_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbBox3s_setBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::setBounds(short,short,short,short,short,short)\n"
    "    SbBox3s::setBounds(SbVec3s const &,SbVec3s const &)\n"
    "    SbBox3s::setBounds(SbBox3i32 const &)\n"
    "    SbBox3s::setBounds(SbBox3f const &)\n"
    "    SbBox3s::setBounds(SbBox3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  short *arg5 = 0 ;
  short *arg6 = 0 ;
  short *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getBounds" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_getBounds" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3s_getBounds" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3s_getBounds" "', argument " "4"" of type '" "short &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "4"" of type '" "short &""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox3s_getBounds" "', argument " "5"" of type '" "short &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "5"" of type '" "short &""'"); 
  }
  arg5 = reinterpret_cast< short * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbBox3s_getBounds" "', argument " "6"" of type '" "short &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "6"" of type '" "short &""'"); 
  }
  arg6 = reinterpret_cast< short * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SbBox3s_getBounds" "', argument " "7"" of type '" "short &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "7"" of type '" "short &""'"); 
  }
  arg7 = reinterpret_cast< short * >(argp7);
  ((SbBox3s const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getBounds" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_getBounds" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3s_getBounds" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getBounds" "', argument " "3"" of type '" "SbVec3s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ((SbBox3s const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_getBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3s_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SbBox3s_getBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::getBounds(short &,short &,short &,short &,short &,short &) const\n"
    "    SbBox3s::getBounds(SbVec3s &,SbVec3s &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getMin" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbVec3s *) &((SbBox3s const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getMin" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbVec3s *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3s_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3s_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::getMin() const\n"
    "    SbBox3s::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getMax" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbVec3s *) &((SbBox3s const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getMax" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbVec3s *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3s_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3s_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::getMax() const\n"
    "    SbBox3s::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_extendBy" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_extendBy" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_extendBy" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  (arg1)->extendBy((SbVec3s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_extendBy" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_extendBy" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_extendBy" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  (arg1)->extendBy((SbBox3s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::extendBy(SbVec3s const &)\n"
    "    SbBox3s::extendBy(SbBox3s const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_makeEmpty" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_isEmpty" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbBool)((SbBox3s const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_hasVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_hasVolume" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbBool)((SbBox3s const *)arg1)->hasVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getVolume" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (int)((SbBox3s const *)arg1)->getVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_intersect" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_intersect" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_intersect" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbBool)((SbBox3s const *)arg1)->intersect((SbVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_intersect" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_intersect" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_intersect" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (SbBool)((SbBox3s const *)arg1)->intersect((SbBox3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3s_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::intersect(SbVec3s const &) const\n"
    "    SbBox3s::intersect(SbBox3s const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3s_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getClosestPoint" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = ((SbBox3s const *)arg1)->getClosestPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getCenter" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = ((SbBox3s const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3s_getOrigin", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getOrigin" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_getOrigin" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getOrigin" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3s_getOrigin" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getOrigin" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3s_getOrigin" "', argument " "4"" of type '" "short &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getOrigin" "', argument " "4"" of type '" "short &""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  ((SbBox3s const *)arg1)->getOrigin(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getSize" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s_getSize" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getSize" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3s_getSize" "', argument " "3"" of type '" "short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getSize" "', argument " "3"" of type '" "short &""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3s_getSize" "', argument " "4"" of type '" "short &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s_getSize" "', argument " "4"" of type '" "short &""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  ((SbBox3s const *)arg1)->getSize(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3s result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s_getSize" "', argument " "1"" of type '" "SbBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = ((SbBox3s const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3s_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3s_getSize", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3s_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbBox3s_getSize__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3s_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3s::getSize(short &,short &,short &) const\n"
    "    SbBox3s::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s___eq__" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s___eq__" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s___eq__" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (int)SbBox3s___eq__(arg1,(SbBox3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbBox3s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3s___ne__" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3s___ne__" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3s___ne__" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (int)SbBox3s___ne__(arg1,(SbBox3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbBox3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox3s" "', argument " "1"" of type '" "SbBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox3s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox3s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox3s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox3s", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox3s *)new SoSFBox3s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox3s" "', argument " "1"" of type '" "SoSFBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox3s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox3s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_getTypeId" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  result = ((SoSFBox3s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_copyFrom" "', argument " "1"" of type '" "SoSFBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_isSame" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox3s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_getValue" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  result = (SbBox3s *) &((SoSFBox3s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_setValue" "', argument " "1"" of type '" "SoSFBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s_setValue" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_setValue" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  (arg1)->setValue((SbBox3s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SoSFBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s___eq__" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s___eq__" "', argument " "2"" of type '" "SoSFBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s___eq__" "', argument " "2"" of type '" "SoSFBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3s * >(argp2);
  result = (int)((SoSFBox3s const *)arg1)->operator ==((SoSFBox3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SoSFBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s___ne__" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s___ne__" "', argument " "2"" of type '" "SoSFBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s___ne__" "', argument " "2"" of type '" "SoSFBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3s * >(argp2);
  result = (int)((SoSFBox3s const *)arg1)->operator !=((SoSFBox3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3s_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox3s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  short arg6 ;
  short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  short val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_setValue" "', argument " "1"" of type '" "SoSFBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox3s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox3s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox3s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox3s_setValue" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoSFBox3s_setValue" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  ecode7 = SWIG_AsVal_short(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoSFBox3s_setValue" "', argument " "7"" of type '" "short""'");
  } 
  arg7 = static_cast< short >(val7);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_setValue" "', argument " "1"" of type '" "SoSFBox3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox3s_setValue" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_setValue" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  (arg1)->setValue((SbVec3s const &)*arg2,(SbVec3s const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3s_setValue", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox3s_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoSFBox3s_setValue__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3s::setValue(SbBox3s const &)\n"
    "    SoSFBox3s::setValue(short,short,short,short,short,short)\n"
    "    SoSFBox3s::setValue(SbVec3s const &,SbVec3s const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3s *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3s_getValue" "', argument " "1"" of type '" "SoSFBox3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3s_getValue" "', argument " "2"" of type '" "SbBox3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3s_getValue" "', argument " "2"" of type '" "SbBox3s &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  ((SoSFBox3s const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3s_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3s_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox3s_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3s_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3s_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3s::getValue() const\n"
    "    SoSFBox3s::getValue(SbBox3s &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox3s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox3s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox3s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec3i32 *)new SbVec3i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t *arg1 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "int32_t const [3]""'"); 
  } 
  arg1 = reinterpret_cast< int32_t * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((int32_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec3i32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec3i32" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  result = (SbVec3i32 *)new SbVec3i32(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3ui32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3ui32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3ui32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3ui32 * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((SbVec3ui32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((SbVec3b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((SbVec3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((SbVec3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3i32" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (SbVec3i32 *)new SbVec3i32((SbVec3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3i32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec3i32", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec3i32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3ui32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3i32__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbVec3i32__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec3i32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3i32::SbVec3i32()\n"
    "    SbVec3i32::SbVec3i32(int32_t const [3])\n"
    "    SbVec3i32::SbVec3i32(int32_t,int32_t,int32_t)\n"
    "    SbVec3i32::SbVec3i32(SbVec3ui32 const &)\n"
    "    SbVec3i32::SbVec3i32(SbVec3b const &)\n"
    "    SbVec3i32::SbVec3i32(SbVec3s const &)\n"
    "    SbVec3i32::SbVec3i32(SbVec3f const &)\n"
    "    SbVec3i32::SbVec3i32(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "int32_t const [3]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec3i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  result = (SbVec3i32 *) &(arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3ui32 * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((SbVec3ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3b * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((SbVec3b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_setValue" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3i32 *) &(arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3i32_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3i32_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbVec3i32_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3i32::setValue(int32_t const [3])\n"
    "    SbVec3i32::setValue(int32_t,int32_t,int32_t)\n"
    "    SbVec3i32::setValue(SbVec3ui32 const &)\n"
    "    SbVec3i32::setValue(SbVec3b const &)\n"
    "    SbVec3i32::setValue(SbVec3s const &)\n"
    "    SbVec3i32::setValue(SbVec3f const &)\n"
    "    SbVec3i32::setValue(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_getValue" "', argument " "1"" of type '" "SbVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = (int32_t *)((SbVec3i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_getValue" "', argument " "1"" of type '" "SbVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec3i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec3i32_getValue" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_getValue" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ((SbVec3i32 const *)arg1)->getValue(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3i32_getValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec3i32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbVec3i32_getValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3i32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3i32::getValue() const\n"
    "    SbVec3i32::getValue(int32_t &,int32_t &,int32_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3i32_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_dot" "', argument " "1"" of type '" "SbVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32_dot" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32_dot" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (int32_t)((SbVec3i32 const *)arg1)->dot((SbVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32_negate" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___imul__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3i32___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___imul__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3i32___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3i32___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3i32___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3i32___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3i32___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3i32::operator *=(int)\n"
    "    SbVec3i32::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___itruediv__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3i32___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___itruediv__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3i32___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3i32___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3i32___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3i32___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3i32___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3i32::operator /=(int)\n"
    "    SbVec3i32::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3i32___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___iadd__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32___iadd__" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32___iadd__" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3i32 *) &(arg1)->operator +=((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3i32___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___isub__" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3i32___isub__" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3i32___isub__" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3i32 *) &(arg1)->operator -=((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3i32___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3i32 result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3i32___neg__" "', argument " "1"" of type '" "SbVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = ((SbVec3i32 const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec3i32(result)), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3i32" "', argument " "1"" of type '" "SbVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox3i32 *)new SbBox3i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  int32_t arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox3i32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox3i32" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox3i32" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbBox3i32" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbBox3i32" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  result = (SbBox3i32 *)new SbBox3i32(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox3i32" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3i32" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbBox3i32 *)new SbBox3i32((SbVec3i32 const &)*arg1,(SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbBox3i32 *)new SbBox3i32((SbBox3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbBox3i32 *)new SbBox3i32((SbBox3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3i32" "', argument " "1"" of type '" "SbBox3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbBox3i32 *)new SbBox3i32((SbBox3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3i32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox3i32", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox3i32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3i32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3i32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3i32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox3i32__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SbBox3i32__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox3i32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::SbBox3i32()\n"
    "    SbBox3i32::SbBox3i32(int32_t,int32_t,int32_t,int32_t,int32_t,int32_t)\n"
    "    SbBox3i32::SbBox3i32(SbVec3i32 const &,SbVec3i32 const &)\n"
    "    SbBox3i32::SbBox3i32(SbBox3s const &)\n"
    "    SbBox3i32::SbBox3i32(SbBox3f const &)\n"
    "    SbBox3i32::SbBox3i32(SbBox3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  int32_t arg6 ;
  int32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_setBounds" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox3i32_setBounds" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox3i32_setBounds" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox3i32_setBounds" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbBox3i32_setBounds" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbBox3i32_setBounds" "', argument " "7"" of type '" "int32_t""'");
  } 
  arg7 = static_cast< int32_t >(val7);
  result = (SbBox3i32 *) &(arg1)->setBounds(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_setBounds" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_setBounds" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_setBounds" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  result = (SbBox3i32 *) &(arg1)->setBounds((SbVec3i32 const &)*arg2,(SbVec3i32 const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_setBounds" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (SbBox3i32 *) &(arg1)->setBounds((SbBox3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_setBounds" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBox3i32 *) &(arg1)->setBounds((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_setBounds" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_setBounds" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  result = (SbBox3i32 *) &(arg1)->setBounds((SbBox3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_setBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3i32_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbBox3i32_setBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::setBounds(int32_t,int32_t,int32_t,int32_t,int32_t,int32_t)\n"
    "    SbBox3i32::setBounds(SbVec3i32 const &,SbVec3i32 const &)\n"
    "    SbBox3i32::setBounds(SbBox3s const &)\n"
    "    SbBox3i32::setBounds(SbBox3f const &)\n"
    "    SbBox3i32::setBounds(SbBox3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  int32_t *arg5 = 0 ;
  int32_t *arg6 = 0 ;
  int32_t *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getBounds" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getBounds" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_getBounds" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3i32_getBounds" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox3i32_getBounds" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  arg5 = reinterpret_cast< int32_t * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbBox3i32_getBounds" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  arg6 = reinterpret_cast< int32_t * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SbBox3i32_getBounds" "', argument " "7"" of type '" "int32_t &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "7"" of type '" "int32_t &""'"); 
  }
  arg7 = reinterpret_cast< int32_t * >(argp7);
  ((SbBox3i32 const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getBounds" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getBounds" "', argument " "2"" of type '" "SbVec3i32 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "2"" of type '" "SbVec3i32 &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3i32,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_getBounds" "', argument " "3"" of type '" "SbVec3i32 &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getBounds" "', argument " "3"" of type '" "SbVec3i32 &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  ((SbBox3i32 const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_getBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3i32_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SbBox3i32_getBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::getBounds(int32_t &,int32_t &,int32_t &,int32_t &,int32_t &,int32_t &) const\n"
    "    SbBox3i32::getBounds(SbVec3i32 &,SbVec3i32 &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getMin" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbVec3i32 *) &((SbBox3i32 const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getMin" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbVec3i32 *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3i32_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3i32_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::getMin() const\n"
    "    SbBox3i32::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getMax" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbVec3i32 *) &((SbBox3i32 const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getMax" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbVec3i32 *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3i32_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3i32_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::getMax() const\n"
    "    SbBox3i32::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_extendBy" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  (arg1)->extendBy((SbVec3i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_extendBy" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  (arg1)->extendBy((SbBox3i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_extendBy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_extendBy" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_extendBy" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->extendBy((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_extendBy__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::extendBy(SbVec3i32 const &)\n"
    "    SbBox3i32::extendBy(SbBox3i32 const &)\n"
    "    SbBox3i32::extendBy(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3i32_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_transform" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_transform" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->transform((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_makeEmpty" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_isEmpty" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbBool)((SbBox3i32 const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_hasVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_hasVolume" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbBool)((SbBox3i32 const *)arg1)->hasVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getVolume" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (float)((SbBox3i32 const *)arg1)->getVolume();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_intersect" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbBool)((SbBox3i32 const *)arg1)->intersect((SbVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_intersect" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  result = (SbBool)((SbBox3i32 const *)arg1)->intersect((SbBox3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_intersect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_intersect" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_intersect" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbBox3i32 const *)arg1)->intersect((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3i32_intersect__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::intersect(SbVec3i32 const &) const\n"
    "    SbBox3i32::intersect(SbBox3i32 const &) const\n"
    "    SbBox3i32::intersect(SbVec3f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_outside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3i32_outside", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_outside" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_outside" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_outside" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (SbBool)((SbBox3i32 const *)arg1)->outside((SbMatrix const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3i32_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getClosestPoint" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = ((SbBox3i32 const *)arg1)->getClosestPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getCenter" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = ((SbBox3i32 const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3i32_getOrigin", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getOrigin" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getOrigin" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getOrigin" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_getOrigin" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getOrigin" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3i32_getOrigin" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getOrigin" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ((SbBox3i32 const *)arg1)->getOrigin(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getSize" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getSize" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSize" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_getSize" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSize" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3i32_getSize" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSize" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  ((SbBox3i32 const *)arg1)->getSize(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3i32 result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getSize" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = ((SbBox3i32 const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec3i32(result)), SWIGTYPE_p_SbVec3i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3i32_getSize", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3i32_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbBox3i32_getSize__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3i32_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3i32::getSize(int32_t &,int32_t &,int32_t &) const\n"
    "    SbBox3i32::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3i32_getSpan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3i32_getSpan", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3i32_getSpan" "', argument " "1"" of type '" "SbBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3i32_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSpan" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3i32_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSpan" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3i32_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3i32_getSpan" "', argument " "4"" of type '" "float &""'"); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ((SbBox3i32 const *)arg1)->getSpan((SbVec3f const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbBox3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox3i32" "', argument " "1"" of type '" "SbBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox3i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox3i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox3i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox3i32", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox3i32 *)new SoSFBox3i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox3i32" "', argument " "1"" of type '" "SoSFBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox3i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox3i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_getTypeId" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  result = ((SoSFBox3i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_copyFrom" "', argument " "1"" of type '" "SoSFBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_isSame" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox3i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_getValue" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  result = (SbBox3i32 *) &((SoSFBox3i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_setValue" "', argument " "1"" of type '" "SoSFBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32_setValue" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_setValue" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  (arg1)->setValue((SbBox3i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SoSFBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32___eq__" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32___eq__" "', argument " "2"" of type '" "SoSFBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32___eq__" "', argument " "2"" of type '" "SoSFBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3i32 * >(argp2);
  result = (int)((SoSFBox3i32 const *)arg1)->operator ==((SoSFBox3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SoSFBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32___ne__" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32___ne__" "', argument " "2"" of type '" "SoSFBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32___ne__" "', argument " "2"" of type '" "SoSFBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3i32 * >(argp2);
  result = (int)((SoSFBox3i32 const *)arg1)->operator !=((SoSFBox3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3i32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox3i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  int32_t arg6 ;
  int32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_setValue" "', argument " "1"" of type '" "SoSFBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox3i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox3i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox3i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox3i32_setValue" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoSFBox3i32_setValue" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoSFBox3i32_setValue" "', argument " "7"" of type '" "int32_t""'");
  } 
  arg7 = static_cast< int32_t >(val7);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_setValue" "', argument " "1"" of type '" "SoSFBox3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox3i32_setValue" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_setValue" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  (arg1)->setValue((SbVec3i32 const &)*arg2,(SbVec3i32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3i32_setValue", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox3i32_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoSFBox3i32_setValue__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3i32::setValue(SbBox3i32 const &)\n"
    "    SoSFBox3i32::setValue(int32_t,int32_t,int32_t,int32_t,int32_t,int32_t)\n"
    "    SoSFBox3i32::setValue(SbVec3i32 const &,SbVec3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3i32 *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3i32_getValue" "', argument " "1"" of type '" "SoSFBox3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3i32_getValue" "', argument " "2"" of type '" "SbBox3i32 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3i32_getValue" "', argument " "2"" of type '" "SbBox3i32 &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  ((SoSFBox3i32 const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3i32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3i32_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox3i32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3i32_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3i32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3i32::getValue() const\n"
    "    SoSFBox3i32::getValue(SbBox3i32 &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox3i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox3i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox3i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox3f", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox3f *)new SoSFBox3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox3f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox3f" "', argument " "1"" of type '" "SoSFBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox3f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_getTypeId" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  result = ((SoSFBox3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_copyFrom" "', argument " "1"" of type '" "SoSFBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_isSame" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox3f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_getValue" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  result = (SbBox3f *) &((SoSFBox3f const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_setValue" "', argument " "1"" of type '" "SoSFBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f_setValue" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_setValue" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  (arg1)->setValue((SbBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SoSFBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f___eq__" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f___eq__" "', argument " "2"" of type '" "SoSFBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f___eq__" "', argument " "2"" of type '" "SoSFBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3f * >(argp2);
  result = (int)((SoSFBox3f const *)arg1)->operator ==((SoSFBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SoSFBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f___ne__" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f___ne__" "', argument " "2"" of type '" "SoSFBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f___ne__" "', argument " "2"" of type '" "SoSFBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3f * >(argp2);
  result = (int)((SoSFBox3f const *)arg1)->operator !=((SoSFBox3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3f_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_setValue" "', argument " "1"" of type '" "SoSFBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox3f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox3f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox3f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox3f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoSFBox3f_setValue" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoSFBox3f_setValue" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_setValue" "', argument " "1"" of type '" "SoSFBox3f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox3f_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setValue((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3f_setValue", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox3f_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoSFBox3f_setValue__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3f::setValue(SbBox3f const &)\n"
    "    SoSFBox3f::setValue(float,float,float,float,float,float)\n"
    "    SoSFBox3f::setValue(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3f *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3f_getValue" "', argument " "1"" of type '" "SoSFBox3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3f_getValue" "', argument " "2"" of type '" "SbBox3f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3f_getValue" "', argument " "2"" of type '" "SbBox3f &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ((SoSFBox3f const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3f_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3f_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox3f_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3f_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3f_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3f::getValue() const\n"
    "    SoSFBox3f::getValue(SbBox3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbBox3d *)new SbBox3d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBox3d" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbBox3d" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbBox3d" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbBox3d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbBox3d" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbBox3d" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (SbBox3d *)new SbBox3d(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbBox3d" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3d" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbBox3d *)new SbBox3d((SbVec3d const &)*arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  result = (SbBox3d *)new SbBox3d((SbBox3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3s * >(argp1);
  result = (SbBox3d *)new SbBox3d((SbBox3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbBox3d" "', argument " "1"" of type '" "SbBox3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3i32 * >(argp1);
  result = (SbBox3d *)new SbBox3d((SbBox3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbBox3d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbBox3d", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbBox3d__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3d__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3d__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbBox3d__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbBox3d__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SbBox3d__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbBox3d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::SbBox3d()\n"
    "    SbBox3d::SbBox3d(double,double,double,double,double,double)\n"
    "    SbBox3d::SbBox3d(SbVec3d const &,SbVec3d const &)\n"
    "    SbBox3d::SbBox3d(SbBox3f const &)\n"
    "    SbBox3d::SbBox3d(SbBox3s const &)\n"
    "    SbBox3d::SbBox3d(SbBox3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_setBounds" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbBox3d_setBounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbBox3d_setBounds" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbBox3d_setBounds" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbBox3d_setBounds" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbBox3d_setBounds" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (SbBox3d *) &(arg1)->setBounds(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_setBounds" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_setBounds" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_setBounds" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  result = (SbBox3d *) &(arg1)->setBounds((SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_setBounds" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  result = (SbBox3d *) &(arg1)->setBounds((SbBox3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbBox3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_setBounds" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3s * >(argp2);
  result = (SbBox3d *) &(arg1)->setBounds((SbBox3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbBox3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_setBounds" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_setBounds" "', argument " "2"" of type '" "SbBox3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3i32 * >(argp2);
  result = (SbBox3d *) &(arg1)->setBounds((SbBox3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_setBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_setBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_setBounds__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_setBounds__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_setBounds__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3d_setBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbBox3d_setBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_setBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::setBounds(double,double,double,double,double,double)\n"
    "    SbBox3d::setBounds(SbVec3d const &,SbVec3d const &)\n"
    "    SbBox3d::setBounds(SbBox3f const &)\n"
    "    SbBox3d::setBounds(SbBox3s const &)\n"
    "    SbBox3d::setBounds(SbBox3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getBounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getBounds" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getBounds" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_getBounds" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3d_getBounds" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbBox3d_getBounds" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbBox3d_getBounds" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SbBox3d_getBounds" "', argument " "7"" of type '" "double &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "7"" of type '" "double &""'"); 
  }
  arg7 = reinterpret_cast< double * >(argp7);
  ((SbBox3d const *)arg1)->getBounds(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getBounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getBounds" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getBounds" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_getBounds" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getBounds" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbBox3d const *)arg1)->getBounds(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getBounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_getBounds", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbBox3d_getBounds__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SbBox3d_getBounds__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_getBounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::getBounds(double &,double &,double &,double &,double &,double &) const\n"
    "    SbBox3d::getBounds(SbVec3d &,SbVec3d &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getMin" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbVec3d *) &((SbBox3d const *)arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getMin" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbVec3d *) &(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_getMin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3d_getMin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3d_getMin__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_getMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::getMin() const\n"
    "    SbBox3d::getMin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMax__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getMax" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbVec3d *) &((SbBox3d const *)arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMax__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getMax" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbVec3d *) &(arg1)->getMax();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_getMax", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3d_getMax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3d_getMax__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_getMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::getMax() const\n"
    "    SbBox3d::getMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_extendBy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_extendBy" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_extendBy" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_extendBy" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->extendBy((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_extendBy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_extendBy" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_extendBy" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_extendBy" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  (arg1)->extendBy((SbBox3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_extendBy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_extendBy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_extendBy__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_extendBy__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_extendBy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::extendBy(SbVec3d const &)\n"
    "    SbBox3d::extendBy(SbBox3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_transform" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_transform" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_transform" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  (arg1)->transform((SbDPMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_makeEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_makeEmpty" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  (arg1)->makeEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_isEmpty" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbBool)((SbBox3d const *)arg1)->isEmpty();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_hasVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_hasVolume" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (SbBool)((SbBox3d const *)arg1)->hasVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getVolume" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = (double)((SbBox3d const *)arg1)->getVolume();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_intersect" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_intersect" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_intersect" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbBool)((SbBox3d const *)arg1)->intersect((SbVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_intersect" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_intersect" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_intersect" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  result = (SbBool)((SbBox3d const *)arg1)->intersect((SbBox3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_intersect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_intersect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbBox3d_intersect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::intersect(SbVec3d const &) const\n"
    "    SbBox3d::intersect(SbBox3d const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getClosestPoint" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getClosestPoint" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getClosestPoint" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = ((SbBox3d const *)arg1)->getClosestPoint((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_outside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_outside", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_outside" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_outside" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_outside" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_outside" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (SbBool)((SbBox3d const *)arg1)->outside((SbDPMatrix const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getCenter" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = ((SbBox3d const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_getOrigin", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getOrigin" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getOrigin" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getOrigin" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_getOrigin" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getOrigin" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3d_getOrigin" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getOrigin" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ((SbBox3d const *)arg1)->getOrigin(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getSize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getSize" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getSize" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSize" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_getSize" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSize" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3d_getSize" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSize" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ((SbBox3d const *)arg1)->getSize(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getSize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3d result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getSize" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  result = ((SbBox3d const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getSize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbBox3d_getSize", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbBox3d_getSize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbBox3d_getSize__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbBox3d_getSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbBox3d::getSize(double &,double &,double &) const\n"
    "    SbBox3d::getSize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbBox3d_getSpan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_getSpan", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_getSpan" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbBox3d_getSpan" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSpan" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbBox3d_getSpan" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSpan" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbBox3d_getSpan" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbBox3d_getSpan" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ((SbBox3d const *)arg1)->getSpan((SbVec3d const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBox3d_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbBox3d_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBox3d_output" "', argument " "1"" of type '" "SbBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbBox3d const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbBox3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBox3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBox3d" "', argument " "1"" of type '" "SbBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SbBox3d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBox3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBox3d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBox3d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFBox3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFBox3d", 0, 0, 0)) SWIG_fail;
  result = (SoSFBox3d *)new SoSFBox3d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBox3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFBox3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFBox3d" "', argument " "1"" of type '" "SoSFBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFBox3d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFBox3d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_getTypeId" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  result = ((SoSFBox3d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_copyFrom" "', argument " "1"" of type '" "SoSFBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_isSame" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFBox3d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBox3d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_getValue" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  result = (SbBox3d *) &((SoSFBox3d const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_setValue" "', argument " "1"" of type '" "SoSFBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d_setValue" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_setValue" "', argument " "2"" of type '" "SbBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  (arg1)->setValue((SbBox3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SoSFBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d___eq__" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d___eq__" "', argument " "2"" of type '" "SoSFBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d___eq__" "', argument " "2"" of type '" "SoSFBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3d * >(argp2);
  result = (int)((SoSFBox3d const *)arg1)->operator ==((SoSFBox3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SoSFBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d___ne__" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFBox3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d___ne__" "', argument " "2"" of type '" "SoSFBox3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d___ne__" "', argument " "2"" of type '" "SoSFBox3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFBox3d * >(argp2);
  result = (int)((SoSFBox3d const *)arg1)->operator !=((SoSFBox3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFBox3d_initClass", 0, 0, 0)) SWIG_fail;
  SoSFBox3d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_setValue" "', argument " "1"" of type '" "SoSFBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFBox3d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFBox3d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFBox3d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFBox3d_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoSFBox3d_setValue" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoSFBox3d_setValue" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_setValue" "', argument " "1"" of type '" "SoSFBox3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSFBox3d_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->setValue((SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3d_setValue", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSFBox3d_setValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoSFBox3d_setValue__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3d::setValue(SbBox3d const &)\n"
    "    SoSFBox3d::setValue(double,double,double,double,double,double)\n"
    "    SoSFBox3d::setValue(SbVec3d const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFBox3d *arg1 = 0 ;
  SbBox3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFBox3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFBox3d_getValue" "', argument " "1"" of type '" "SoSFBox3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFBox3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFBox3d_getValue" "', argument " "2"" of type '" "SbBox3d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFBox3d_getValue" "', argument " "2"" of type '" "SbBox3d &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3d * >(argp2);
  ((SoSFBox3d const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFBox3d_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFBox3d_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSFBox3d_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFBox3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbBox3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFBox3d_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFBox3d_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFBox3d::getValue() const\n"
    "    SoSFBox3d::getValue(SbBox3d &) const\n");
  return 0;
}


SWIGINTERN PyObject *SoSFBox3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFBox3d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFBox3d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFColorRGBA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFColorRGBA", 0, 0, 0)) SWIG_fail;
  result = (SoSFColorRGBA *)new SoSFColorRGBA();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColorRGBA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFColorRGBA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFColorRGBA" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFColorRGBA::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFColorRGBA::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_getTypeId" "', argument " "1"" of type '" "SoSFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  result = ((SoSFColorRGBA const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_copyFrom" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_isSame" "', argument " "1"" of type '" "SoSFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFColorRGBA const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_getValue" "', argument " "1"" of type '" "SoSFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  result = (SbColor4f *) &((SoSFColorRGBA const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  (arg1)->setValue((SbColor4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SoSFColorRGBA *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA___eq__" "', argument " "1"" of type '" "SoSFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFColorRGBA,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA___eq__" "', argument " "2"" of type '" "SoSFColorRGBA const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA___eq__" "', argument " "2"" of type '" "SoSFColorRGBA const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFColorRGBA * >(argp2);
  result = (int)((SoSFColorRGBA const *)arg1)->operator ==((SoSFColorRGBA const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SoSFColorRGBA *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA___ne__" "', argument " "1"" of type '" "SoSFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFColorRGBA,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA___ne__" "', argument " "2"" of type '" "SoSFColorRGBA const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA___ne__" "', argument " "2"" of type '" "SoSFColorRGBA const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFColorRGBA * >(argp2);
  result = (int)((SoSFColorRGBA const *)arg1)->operator !=((SoSFColorRGBA const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_initClass", 0, 0, 0)) SWIG_fail;
  SoSFColorRGBA::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFColorRGBA_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFColorRGBA_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFColorRGBA_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_setValue" "', argument " "2"" of type '" "float const [4]""'"); 
  } 
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColorRGBA_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColorRGBA_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColorRGBA_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFColorRGBA_setValue__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFColorRGBA_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFColorRGBA::setValue(SbColor4f const &)\n"
    "    SoSFColorRGBA::setValue(SbVec4f const &)\n"
    "    SoSFColorRGBA::setValue(float,float,float,float)\n"
    "    SoSFColorRGBA::setValue(float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setHSVValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFColorRGBA *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "1"" of type '" "SoSFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoSFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFColorRGBA_setHSVValue" "', argument " "2"" of type '" "float const [4]""'"); 
  } 
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFColorRGBA_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFColorRGBA_setHSVValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFColorRGBA_setHSVValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFColorRGBA_setHSVValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFColorRGBA_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFColorRGBA::setHSVValue(float,float,float,float)\n"
    "    SoSFColorRGBA::setHSVValue(float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFColorRGBA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFColorRGBA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFColorRGBA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFDouble", 0, 0, 0)) SWIG_fail;
  result = (SoSFDouble *)new SoSFDouble();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFDouble, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFDouble" "', argument " "1"" of type '" "SoSFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFDouble::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFDouble::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble_getTypeId" "', argument " "1"" of type '" "SoSFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  result = ((SoSFDouble const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble_copyFrom" "', argument " "1"" of type '" "SoSFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFDouble_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFDouble_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble_isSame" "', argument " "1"" of type '" "SoSFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFDouble_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFDouble_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFDouble const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble_getValue" "', argument " "1"" of type '" "SoSFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  result = (double)((SoSFDouble const *)arg1)->getValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble_setValue" "', argument " "1"" of type '" "SoSFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFDouble_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFDouble___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  SoSFDouble *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble___eq__" "', argument " "1"" of type '" "SoSFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFDouble,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFDouble___eq__" "', argument " "2"" of type '" "SoSFDouble const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFDouble___eq__" "', argument " "2"" of type '" "SoSFDouble const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFDouble * >(argp2);
  result = (int)((SoSFDouble const *)arg1)->operator ==((SoSFDouble const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFDouble___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFDouble *arg1 = 0 ;
  SoSFDouble *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFDouble___ne__" "', argument " "1"" of type '" "SoSFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFDouble,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFDouble___ne__" "', argument " "2"" of type '" "SoSFDouble const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFDouble___ne__" "', argument " "2"" of type '" "SoSFDouble const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFDouble * >(argp2);
  result = (int)((SoSFDouble const *)arg1)->operator !=((SoSFDouble const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFDouble_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFDouble_initClass", 0, 0, 0)) SWIG_fail;
  SoSFDouble::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSFDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFDouble, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFDouble_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFEngine", 0, 0, 0)) SWIG_fail;
  result = (SoSFEngine *)new SoSFEngine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEngine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFEngine" "', argument " "1"" of type '" "SoSFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFEngine::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFEngine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_getTypeId" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  result = ((SoSFEngine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_copyFrom" "', argument " "1"" of type '" "SoSFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEngine_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_isSame" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEngine_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFEngine const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_getValue" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  result = (SoEngine *)((SoSFEngine const *)arg1)->getValue();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_setValue" "', argument " "1"" of type '" "SoSFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine_setValue" "', argument " "2"" of type '" "SoEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoSFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine___eq__" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFEngine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine___eq__" "', argument " "2"" of type '" "SoSFEngine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEngine___eq__" "', argument " "2"" of type '" "SoSFEngine const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFEngine * >(argp2);
  result = (int)((SoSFEngine const *)arg1)->operator ==((SoSFEngine const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFEngine___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoSFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine___ne__" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFEngine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine___ne__" "', argument " "2"" of type '" "SoSFEngine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFEngine___ne__" "', argument " "2"" of type '" "SoSFEngine const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFEngine * >(argp2);
  result = (int)((SoSFEngine const *)arg1)->operator !=((SoSFEngine const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_initClass", 0, 0, 0)) SWIG_fail;
  SoSFEngine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFEngine_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_fixCopy" "', argument " "1"" of type '" "SoSFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFEngine_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_referencesCopy" "', argument " "1"" of type '" "SoSFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  result = (SbBool)((SoSFEngine const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFEngine *arg1 = 0 ;
  SoSFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFEngine_setValue" "', argument " "1"" of type '" "SoSFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoSFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFEngine_setValue" "', argument " "2"" of type '" "SoSFEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEngine * >(argp2);
  SoSFEngine_setValue__SWIG_1(arg1,(SoSFEngine const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFEngine_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFEngine_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFEngine_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFEngine_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFEngine_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFEngine::setValue(SoEngine *)\n"
    "    SoSFEngine::setValue(SoSFEngine const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFEngine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFImage3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFImage3", 0, 0, 0)) SWIG_fail;
  result = (SoSFImage3 *)new SoSFImage3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage3, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFImage3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFImage3" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFImage3::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFImage3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_getTypeId" "', argument " "1"" of type '" "SoSFImage3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  result = ((SoSFImage3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_copyFrom" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_isSame" "', argument " "1"" of type '" "SoSFImage3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFImage3 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3_initClass", 0, 0, 0)) SWIG_fail;
  SoSFImage3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject *swig_obj[1] ;
  unsigned char *result = 0 ;
  
  {
    arg2 = new SbVec3s();
    arg3 = &temp2;
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_getValue" "', argument " "1"" of type '" "SoSFImage3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  result = (unsigned char *)((SoSFImage3 const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = Py_BuildValue("(s#Oi)",
      (const char *)result,
      (*arg2)[0] * (*arg2)[1] * (*arg2)[2] * (*arg3),
      SWIG_NewPointerObj((void *)arg2, SWIGTYPE_p_SbVec3s, 1),
      *arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_setValue" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFImage3_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoSFImage3_setValue" "', argument " "4"" of type '" "unsigned char const *""'"); 
  }
  arg4 = reinterpret_cast< unsigned char * >(argp4);
  (arg1)->setValue((SbVec3s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SoSFImage3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3___eq__" "', argument " "1"" of type '" "SoSFImage3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFImage3,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3___eq__" "', argument " "2"" of type '" "SoSFImage3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3___eq__" "', argument " "2"" of type '" "SoSFImage3 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage3 * >(argp2);
  result = (int)((SoSFImage3 const *)arg1)->operator ==((SoSFImage3 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFImage3___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SoSFImage3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFImage3___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3___ne__" "', argument " "1"" of type '" "SoSFImage3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFImage3,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3___ne__" "', argument " "2"" of type '" "SoSFImage3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3___ne__" "', argument " "2"" of type '" "SoSFImage3 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage3 * >(argp2);
  result = (int)((SoSFImage3 const *)arg1)->operator !=((SoSFImage3 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject *swig_obj[1] ;
  unsigned char *result = 0 ;
  
  {
    arg2 = new SbVec3s();
    arg3 = &temp2;
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_startEditing" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  result = (unsigned char *)(arg1)->startEditing(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = Py_BuildValue("(s#Oi)",
      (const char *)result,
      (*arg2)[0] * (*arg2)[1] * (*arg2)[2] * (*arg3),
      SWIG_NewPointerObj((void *)arg2, SWIGTYPE_p_SbVec3s, 1),
      *arg3);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_finishEditing" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int arg3 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_setValue" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFImage3_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFImage3_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  arg4 = swig_obj[3];
  SoSFImage3_setValue__SWIG_1(arg1,(SbVec3s const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFImage3 *arg1 = 0 ;
  SoSFImage3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFImage3_setValue" "', argument " "1"" of type '" "SoSFImage3 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFImage3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFImage3_setValue" "', argument " "2"" of type '" "SoSFImage3 const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage3 * >(argp2);
  SoSFImage3_setValue__SWIG_2(arg1,(SoSFImage3 const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFImage3_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFImage3_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFImage3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFImage3_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoSFImage3_setValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFImage3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoSFImage3_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFImage3_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFImage3::setValue(SbVec3s const &,int const,unsigned char const *)\n"
    "    SoSFImage3::setValue(SbVec3s const &,int const,PyObject *)\n"
    "    SoSFImage3::setValue(SoSFImage3 const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFImage3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFImage3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFImage3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFMatrix", 0, 0, 0)) SWIG_fail;
  result = (SoSFMatrix *)new SoSFMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFMatrix" "', argument " "1"" of type '" "SoSFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFMatrix::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFMatrix::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_getTypeId" "', argument " "1"" of type '" "SoSFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  result = ((SoSFMatrix const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_copyFrom" "', argument " "1"" of type '" "SoSFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFMatrix_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_isSame" "', argument " "1"" of type '" "SoSFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFMatrix_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFMatrix const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_getValue" "', argument " "1"" of type '" "SoSFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  result = (SbMatrix *) &((SoSFMatrix const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_setValue" "', argument " "1"" of type '" "SoSFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setValue((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix___eq__" "', argument " "1"" of type '" "SoSFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix___eq__" "', argument " "2"" of type '" "SoSFMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFMatrix___eq__" "', argument " "2"" of type '" "SoSFMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  result = (int)((SoSFMatrix const *)arg1)->operator ==((SoSFMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix___ne__" "', argument " "1"" of type '" "SoSFMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix___ne__" "', argument " "2"" of type '" "SoSFMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFMatrix___ne__" "', argument " "2"" of type '" "SoSFMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  result = (int)((SoSFMatrix const *)arg1)->operator !=((SoSFMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFMatrix_initClass", 0, 0, 0)) SWIG_fail;
  SoSFMatrix::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  float arg8 ;
  float arg9 ;
  float arg10 ;
  float arg11 ;
  float arg12 ;
  float arg13 ;
  float arg14 ;
  float arg15 ;
  float arg16 ;
  float arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  float val14 ;
  int ecode14 = 0 ;
  float val15 ;
  int ecode15 = 0 ;
  float val16 ;
  int ecode16 = 0 ;
  float val17 ;
  int ecode17 = 0 ;
  
  (void)self;
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_setValue" "', argument " "1"" of type '" "SoSFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFMatrix_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFMatrix_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFMatrix_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFMatrix_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoSFMatrix_setValue" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoSFMatrix_setValue" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoSFMatrix_setValue" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_float(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoSFMatrix_setValue" "', argument " "9"" of type '" "float""'");
  } 
  arg9 = static_cast< float >(val9);
  ecode10 = SWIG_AsVal_float(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SoSFMatrix_setValue" "', argument " "10"" of type '" "float""'");
  } 
  arg10 = static_cast< float >(val10);
  ecode11 = SWIG_AsVal_float(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SoSFMatrix_setValue" "', argument " "11"" of type '" "float""'");
  } 
  arg11 = static_cast< float >(val11);
  ecode12 = SWIG_AsVal_float(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SoSFMatrix_setValue" "', argument " "12"" of type '" "float""'");
  } 
  arg12 = static_cast< float >(val12);
  ecode13 = SWIG_AsVal_float(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SoSFMatrix_setValue" "', argument " "13"" of type '" "float""'");
  } 
  arg13 = static_cast< float >(val13);
  ecode14 = SWIG_AsVal_float(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "SoSFMatrix_setValue" "', argument " "14"" of type '" "float""'");
  } 
  arg14 = static_cast< float >(val14);
  ecode15 = SWIG_AsVal_float(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "SoSFMatrix_setValue" "', argument " "15"" of type '" "float""'");
  } 
  arg15 = static_cast< float >(val15);
  ecode16 = SWIG_AsVal_float(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "SoSFMatrix_setValue" "', argument " "16"" of type '" "float""'");
  } 
  arg16 = static_cast< float >(val16);
  ecode17 = SWIG_AsVal_float(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "SoSFMatrix_setValue" "', argument " "17"" of type '" "float""'");
  } 
  arg17 = static_cast< float >(val17);
  (arg1)->setValue(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFMatrix *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFMatrix_setValue" "', argument " "1"" of type '" "SoSFMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoSFMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFMatrix_setValue" "', argument " "2"" of type '" "SoSFMatrix const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  SoSFMatrix_setValue__SWIG_2(arg1,(SoSFMatrix const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFMatrix_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[18] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFMatrix_setValue", 0, 17, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFMatrix_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFMatrix_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_float(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_float(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_float(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_float(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_SoSFMatrix_setValue__SWIG_1(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFMatrix_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFMatrix::setValue(SbMatrix const &)\n"
    "    SoSFMatrix::setValue(float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const,float const)\n"
    "    SoSFMatrix::setValue(SoSFMatrix const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFPlane", 0, 0, 0)) SWIG_fail;
  result = (SoSFPlane *)new SoSFPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFPlane" "', argument " "1"" of type '" "SoSFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFPlane::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFPlane::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_getTypeId" "', argument " "1"" of type '" "SoSFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  result = ((SoSFPlane const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_copyFrom" "', argument " "1"" of type '" "SoSFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPlane_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_isSame" "', argument " "1"" of type '" "SoSFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPlane_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFPlane const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbPlane *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_getValue" "', argument " "1"" of type '" "SoSFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  result = (SbPlane *) &((SoSFPlane const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_setValue" "', argument " "1"" of type '" "SoSFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane_setValue" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPlane_setValue" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  (arg1)->setValue((SbPlane const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SoSFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane___eq__" "', argument " "1"" of type '" "SoSFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane___eq__" "', argument " "2"" of type '" "SoSFPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPlane___eq__" "', argument " "2"" of type '" "SoSFPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFPlane * >(argp2);
  result = (int)((SoSFPlane const *)arg1)->operator ==((SoSFPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFPlane___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SoSFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane___ne__" "', argument " "1"" of type '" "SoSFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane___ne__" "', argument " "2"" of type '" "SoSFPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFPlane___ne__" "', argument " "2"" of type '" "SoSFPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFPlane * >(argp2);
  result = (int)((SoSFPlane const *)arg1)->operator !=((SoSFPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFPlane_initClass", 0, 0, 0)) SWIG_fail;
  SoSFPlane::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFPlane *arg1 = 0 ;
  SoSFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFPlane_setValue" "', argument " "1"" of type '" "SoSFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoSFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFPlane_setValue" "', argument " "2"" of type '" "SoSFPlane const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFPlane * >(argp2);
  SoSFPlane_setValue__SWIG_1(arg1,(SoSFPlane const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFPlane_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFPlane_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFPlane_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFPlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFPlane_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFPlane_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFPlane::setValue(SbPlane const &)\n"
    "    SoSFPlane::setValue(SoSFPlane const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFPlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFPlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFPlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFUInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFUInt32", 0, 0, 0)) SWIG_fail;
  result = (SoSFUInt32 *)new SoSFUInt32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFUInt32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFUInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFUInt32" "', argument " "1"" of type '" "SoSFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFUInt32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFUInt32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_getTypeId" "', argument " "1"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  result = ((SoSFUInt32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_copyFrom" "', argument " "1"" of type '" "SoSFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_isSame" "', argument " "1"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFUInt32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_getValue" "', argument " "1"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  result = (uint32_t)((SoSFUInt32 const *)arg1)->getValue();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_setValue" "', argument " "1"" of type '" "SoSFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFUInt32_setValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  SoSFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32___eq__" "', argument " "1"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFUInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUInt32___eq__" "', argument " "2"" of type '" "SoSFUInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUInt32___eq__" "', argument " "2"" of type '" "SoSFUInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFUInt32 * >(argp2);
  result = (int)((SoSFUInt32 const *)arg1)->operator ==((SoSFUInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  SoSFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32___ne__" "', argument " "1"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFUInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUInt32___ne__" "', argument " "2"" of type '" "SoSFUInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFUInt32___ne__" "', argument " "2"" of type '" "SoSFUInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFUInt32 * >(argp2);
  result = (int)((SoSFUInt32 const *)arg1)->operator !=((SoSFUInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFUInt32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFUInt32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFUInt32 *arg1 = 0 ;
  SoSFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFUInt32_setValue" "', argument " "1"" of type '" "SoSFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFUInt32_setValue" "', argument " "2"" of type '" "SoSFUInt32 const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFUInt32 * >(argp2);
  SoSFUInt32_setValue__SWIG_1(arg1,(SoSFUInt32 const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFUInt32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFUInt32_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFUInt32, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFUInt32_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSFUInt32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFUInt32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFUInt32::setValue(uint32_t)\n"
    "    SoSFUInt32::setValue(SoSFUInt32 const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFUInt32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFUInt32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFUInt32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec2b *)new SbVec2b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t *arg1 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "int8_t const [2]""'"); 
  } 
  arg1 = reinterpret_cast< int8_t * >(argp1);
  result = (SbVec2b *)new SbVec2b((int8_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t arg1 ;
  int8_t arg2 ;
  signed char val1 ;
  int ecode1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_signed_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "int8_t""'");
  } 
  arg1 = static_cast< int8_t >(val1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec2b" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  result = (SbVec2b *)new SbVec2b(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2ub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2ub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2ub const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2ub * >(argp1);
  result = (SbVec2b *)new SbVec2b((SbVec2ub const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2s * >(argp1);
  result = (SbVec2b *)new SbVec2b((SbVec2s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2i32 * >(argp1);
  result = (SbVec2b *)new SbVec2b((SbVec2i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2f * >(argp1);
  result = (SbVec2b *)new SbVec2b((SbVec2f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec2b" "', argument " "1"" of type '" "SbVec2d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec2d * >(argp1);
  result = (SbVec2b *)new SbVec2b((SbVec2d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec2b(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec2b", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec2b__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_signed_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2ub, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec2b__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_signed_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbVec2b__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec2b'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2b::SbVec2b()\n"
    "    SbVec2b::SbVec2b(int8_t const [2])\n"
    "    SbVec2b::SbVec2b(int8_t,int8_t)\n"
    "    SbVec2b::SbVec2b(SbVec2ub const &)\n"
    "    SbVec2b::SbVec2b(SbVec2s const &)\n"
    "    SbVec2b::SbVec2b(SbVec2i32 const &)\n"
    "    SbVec2b::SbVec2b(SbVec2f const &)\n"
    "    SbVec2b::SbVec2b(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "int8_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec2b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  result = (SbVec2b *) &(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2ub const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2ub * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((SbVec2ub const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((SbVec2s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_setValue" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (SbVec2b *) &(arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2b_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec2b_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbVec2b_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2b::setValue(int8_t const [2])\n"
    "    SbVec2b::setValue(int8_t,int8_t)\n"
    "    SbVec2b::setValue(SbVec2ub const &)\n"
    "    SbVec2b::setValue(SbVec2s const &)\n"
    "    SbVec2b::setValue(SbVec2i32 const &)\n"
    "    SbVec2b::setValue(SbVec2f const &)\n"
    "    SbVec2b::setValue(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2b_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int8_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_getValue" "', argument " "1"" of type '" "SbVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = (int8_t *)((SbVec2b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  int8_t *arg2 = 0 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_getValue" "', argument " "1"" of type '" "SbVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  arg2 = reinterpret_cast< int8_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec2b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  ((SbVec2b const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2b_getValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec2b_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbVec2b_getValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2b_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2b::getValue() const\n"
    "    SbVec2b::getValue(int8_t &,int8_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2b_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2b_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_dot" "', argument " "1"" of type '" "SbVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b_dot" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b_dot" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int32_t)((SbVec2b const *)arg1)->dot(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b_negate" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___imul__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2b___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___imul__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2b___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2b___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2b___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2b___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2b___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2b::operator *=(int)\n"
    "    SbVec2b::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2b___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___itruediv__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2b___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___itruediv__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec2b___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec2b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec2b___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2b___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec2b___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec2b___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec2b::operator /=(int)\n"
    "    SbVec2b::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec2b___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2b___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___iadd__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b___iadd__" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b___iadd__" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec2b *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec2b___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___isub__" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec2b___isub__" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec2b___isub__" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec2b *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec2b___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec2b___neg__" "', argument " "1"" of type '" "SbVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  result = ((SbVec2b const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec2b(result)), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec2b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec2b" "', argument " "1"" of type '" "SbVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec2b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec2b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec2b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec2b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec2b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec2b", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec2b *)new SoSFVec2b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec2b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec2b" "', argument " "1"" of type '" "SoSFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec2b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec2b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_getTypeId" "', argument " "1"" of type '" "SoSFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  result = ((SoSFVec2b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_copyFrom" "', argument " "1"" of type '" "SoSFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_isSame" "', argument " "1"" of type '" "SoSFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec2b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_getValue" "', argument " "1"" of type '" "SoSFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  result = ((SoSFVec2b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj((new SbVec2b(result)), SWIGTYPE_p_SbVec2b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_setValue" "', argument " "1"" of type '" "SoSFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b_setValue" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2b_setValue" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  SoSFVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b___eq__" "', argument " "1"" of type '" "SoSFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b___eq__" "', argument " "2"" of type '" "SoSFVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2b___eq__" "', argument " "2"" of type '" "SoSFVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2b * >(argp2);
  result = (int)((SoSFVec2b const *)arg1)->operator ==((SoSFVec2b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  SoSFVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b___ne__" "', argument " "1"" of type '" "SoSFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b___ne__" "', argument " "2"" of type '" "SoSFVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2b___ne__" "', argument " "2"" of type '" "SoSFVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2b * >(argp2);
  result = (int)((SoSFVec2b const *)arg1)->operator !=((SoSFVec2b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2b_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec2b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_setValue" "', argument " "1"" of type '" "SoSFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec2b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec2b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2b_setValue" "', argument " "1"" of type '" "SoSFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2b_setValue" "', argument " "2"" of type '" "int8_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec2b_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFVec2b_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec2b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec2b::setValue(SbVec2b)\n"
    "    SoSFVec2b::setValue(int8_t,int8_t)\n"
    "    SoSFVec2b::setValue(int8_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec2b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec2b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec2b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec2s", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec2s *)new SoSFVec2s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec2s" "', argument " "1"" of type '" "SoSFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec2s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec2s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_getTypeId" "', argument " "1"" of type '" "SoSFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  result = ((SoSFVec2s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_copyFrom" "', argument " "1"" of type '" "SoSFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_isSame" "', argument " "1"" of type '" "SoSFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec2s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_getValue" "', argument " "1"" of type '" "SoSFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  result = ((SoSFVec2s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_setValue" "', argument " "1"" of type '" "SoSFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s_setValue" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2s_setValue" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  SoSFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s___eq__" "', argument " "1"" of type '" "SoSFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s___eq__" "', argument " "2"" of type '" "SoSFVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2s___eq__" "', argument " "2"" of type '" "SoSFVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2s * >(argp2);
  result = (int)((SoSFVec2s const *)arg1)->operator ==((SoSFVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  SoSFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s___ne__" "', argument " "1"" of type '" "SoSFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s___ne__" "', argument " "2"" of type '" "SoSFVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2s___ne__" "', argument " "2"" of type '" "SoSFVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2s * >(argp2);
  result = (int)((SoSFVec2s const *)arg1)->operator !=((SoSFVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2s_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec2s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_setValue" "', argument " "1"" of type '" "SoSFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec2s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec2s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2s_setValue" "', argument " "1"" of type '" "SoSFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2s_setValue" "', argument " "2"" of type '" "short const [2]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec2s_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFVec2s_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec2s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec2s::setValue(SbVec2s)\n"
    "    SoSFVec2s::setValue(short,short)\n"
    "    SoSFVec2s::setValue(short const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec2s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec2s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec2s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec2i32", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec2i32 *)new SoSFVec2i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec2i32" "', argument " "1"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec2i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec2i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_getTypeId" "', argument " "1"" of type '" "SoSFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  result = ((SoSFVec2i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_copyFrom" "', argument " "1"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_isSame" "', argument " "1"" of type '" "SoSFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec2i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_getValue" "', argument " "1"" of type '" "SoSFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  result = (SbVec2i32 *) &((SoSFVec2i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_setValue" "', argument " "1"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  (arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  SoSFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32___eq__" "', argument " "1"" of type '" "SoSFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32___eq__" "', argument " "2"" of type '" "SoSFVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2i32___eq__" "', argument " "2"" of type '" "SoSFVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2i32 * >(argp2);
  result = (int)((SoSFVec2i32 const *)arg1)->operator ==((SoSFVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  SoSFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32___ne__" "', argument " "1"" of type '" "SoSFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32___ne__" "', argument " "2"" of type '" "SoSFVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2i32___ne__" "', argument " "2"" of type '" "SoSFVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2i32 * >(argp2);
  result = (int)((SoSFVec2i32 const *)arg1)->operator !=((SoSFVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2i32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec2i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_setValue" "', argument " "1"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec2i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec2i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2i32_setValue" "', argument " "1"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2i32_setValue" "', argument " "2"" of type '" "int32_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec2i32_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFVec2i32_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec2i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec2i32::setValue(SbVec2i32 const &)\n"
    "    SoSFVec2i32::setValue(int32_t,int32_t)\n"
    "    SoSFVec2i32::setValue(int32_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec2i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec2i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec2i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec2d", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec2d *)new SoSFVec2d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec2d" "', argument " "1"" of type '" "SoSFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec2d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec2d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_getTypeId" "', argument " "1"" of type '" "SoSFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  result = ((SoSFVec2d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_copyFrom" "', argument " "1"" of type '" "SoSFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_isSame" "', argument " "1"" of type '" "SoSFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec2d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_getValue" "', argument " "1"" of type '" "SoSFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  result = (SbVec2d *) &((SoSFVec2d const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_setValue" "', argument " "1"" of type '" "SoSFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  (arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  SoSFVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d___eq__" "', argument " "1"" of type '" "SoSFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d___eq__" "', argument " "2"" of type '" "SoSFVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2d___eq__" "', argument " "2"" of type '" "SoSFVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2d * >(argp2);
  result = (int)((SoSFVec2d const *)arg1)->operator ==((SoSFVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  SoSFVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d___ne__" "', argument " "1"" of type '" "SoSFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d___ne__" "', argument " "2"" of type '" "SoSFVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec2d___ne__" "', argument " "2"" of type '" "SoSFVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2d * >(argp2);
  result = (int)((SoSFVec2d const *)arg1)->operator !=((SoSFVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec2d_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec2d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_setValue" "', argument " "1"" of type '" "SoSFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec2d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec2d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec2d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec2d_setValue" "', argument " "1"" of type '" "SoSFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec2d_setValue" "', argument " "2"" of type '" "double const [2]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec2d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec2d_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec2d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSFVec2d_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec2d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec2d::setValue(SbVec2d const &)\n"
    "    SoSFVec2d::setValue(double,double)\n"
    "    SoSFVec2d::setValue(double const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec2d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec2d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec3b *)new SbVec3b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t *arg1 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "int8_t const [3]""'"); 
  } 
  arg1 = reinterpret_cast< int8_t * >(argp1);
  result = (SbVec3b *)new SbVec3b((int8_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t arg1 ;
  int8_t arg2 ;
  int8_t arg3 ;
  signed char val1 ;
  int ecode1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_signed_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "int8_t""'");
  } 
  arg1 = static_cast< int8_t >(val1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec3b" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec3b" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  result = (SbVec3b *)new SbVec3b(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3ub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3ub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3ub const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3ub * >(argp1);
  result = (SbVec3b *)new SbVec3b((SbVec3ub const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3s * >(argp1);
  result = (SbVec3b *)new SbVec3b((SbVec3s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3i32 * >(argp1);
  result = (SbVec3b *)new SbVec3b((SbVec3i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  result = (SbVec3b *)new SbVec3b((SbVec3f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec3b" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  result = (SbVec3b *)new SbVec3b((SbVec3d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec3b(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec3b", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec3b__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_signed_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3ub, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec3b__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_signed_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbVec3b__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec3b'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3b::SbVec3b()\n"
    "    SbVec3b::SbVec3b(int8_t const [3])\n"
    "    SbVec3b::SbVec3b(int8_t,int8_t,int8_t)\n"
    "    SbVec3b::SbVec3b(SbVec3ub const &)\n"
    "    SbVec3b::SbVec3b(SbVec3s const &)\n"
    "    SbVec3b::SbVec3b(SbVec3i32 const &)\n"
    "    SbVec3b::SbVec3b(SbVec3f const &)\n"
    "    SbVec3b::SbVec3b(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "int8_t [3]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec3b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  result = (SbVec3b *) &(arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3ub const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3ub * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue((SbVec3ub const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_setValue" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbVec3b *) &(arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3b_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec3b_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbVec3b_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3b::setValue(int8_t [3])\n"
    "    SbVec3b::setValue(int8_t,int8_t,int8_t)\n"
    "    SbVec3b::setValue(SbVec3ub const &)\n"
    "    SbVec3b::setValue(SbVec3s const &)\n"
    "    SbVec3b::setValue(SbVec3i32 const &)\n"
    "    SbVec3b::setValue(SbVec3f const &)\n"
    "    SbVec3b::setValue(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3b_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int8_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_getValue" "', argument " "1"" of type '" "SbVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = (int8_t *)((SbVec3b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  int8_t *arg2 = 0 ;
  int8_t *arg3 = 0 ;
  int8_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_getValue" "', argument " "1"" of type '" "SbVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  arg2 = reinterpret_cast< int8_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec3b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec3b_getValue" "', argument " "4"" of type '" "int8_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_getValue" "', argument " "4"" of type '" "int8_t &""'"); 
  }
  arg4 = reinterpret_cast< int8_t * >(argp4);
  ((SbVec3b const *)arg1)->getValue(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3b_getValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec3b_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbVec3b_getValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3b_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3b::getValue() const\n"
    "    SbVec3b::getValue(int8_t &,int8_t &,int8_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3b_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3b_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_dot" "', argument " "1"" of type '" "SbVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b_dot" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b_dot" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int32_t)((SbVec3b const *)arg1)->dot(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b_negate" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___imul__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3b___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___imul__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3b___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3b___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3b___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3b___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3b___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3b::operator *=(int)\n"
    "    SbVec3b::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3b___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___itruediv__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3b___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___itruediv__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3b___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec3b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec3b___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3b___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec3b___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec3b___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec3b::operator /=(int)\n"
    "    SbVec3b::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec3b___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3b___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___iadd__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b___iadd__" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b___iadd__" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec3b *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3b___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___isub__" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3b___isub__" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec3b___isub__" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec3b *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3b___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3b___neg__" "', argument " "1"" of type '" "SbVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  result = ((SbVec3b const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec3b(result)), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3b" "', argument " "1"" of type '" "SbVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec3b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec3b", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec3b *)new SoSFVec3b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec3b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec3b" "', argument " "1"" of type '" "SoSFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec3b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec3b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_getTypeId" "', argument " "1"" of type '" "SoSFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  result = ((SoSFVec3b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_copyFrom" "', argument " "1"" of type '" "SoSFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_isSame" "', argument " "1"" of type '" "SoSFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec3b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_getValue" "', argument " "1"" of type '" "SoSFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  result = ((SoSFVec3b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj((new SbVec3b(result)), SWIGTYPE_p_SbVec3b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_setValue" "', argument " "1"" of type '" "SoSFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b_setValue" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3b_setValue" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  SoSFVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b___eq__" "', argument " "1"" of type '" "SoSFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b___eq__" "', argument " "2"" of type '" "SoSFVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3b___eq__" "', argument " "2"" of type '" "SoSFVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3b * >(argp2);
  result = (int)((SoSFVec3b const *)arg1)->operator ==((SoSFVec3b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  SoSFVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b___ne__" "', argument " "1"" of type '" "SoSFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b___ne__" "', argument " "2"" of type '" "SoSFVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3b___ne__" "', argument " "2"" of type '" "SoSFVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3b * >(argp2);
  result = (int)((SoSFVec3b const *)arg1)->operator !=((SoSFVec3b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3b_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec3b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_setValue" "', argument " "1"" of type '" "SoSFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec3b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec3b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec3b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3b_setValue" "', argument " "1"" of type '" "SoSFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3b_setValue" "', argument " "2"" of type '" "int8_t const [3]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec3b_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFVec3b_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec3b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec3b::setValue(SbVec3b)\n"
    "    SoSFVec3b::setValue(int8_t,int8_t,int8_t)\n"
    "    SoSFVec3b::setValue(int8_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec3b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec3b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec3b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec3s", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec3s *)new SoSFVec3s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec3s" "', argument " "1"" of type '" "SoSFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec3s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec3s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_getTypeId" "', argument " "1"" of type '" "SoSFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  result = ((SoSFVec3s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_copyFrom" "', argument " "1"" of type '" "SoSFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_isSame" "', argument " "1"" of type '" "SoSFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec3s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_getValue" "', argument " "1"" of type '" "SoSFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  result = (SbVec3s *) &((SoSFVec3s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_setValue" "', argument " "1"" of type '" "SoSFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  (arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  SoSFVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s___eq__" "', argument " "1"" of type '" "SoSFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s___eq__" "', argument " "2"" of type '" "SoSFVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3s___eq__" "', argument " "2"" of type '" "SoSFVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3s * >(argp2);
  result = (int)((SoSFVec3s const *)arg1)->operator ==((SoSFVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  SoSFVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s___ne__" "', argument " "1"" of type '" "SoSFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s___ne__" "', argument " "2"" of type '" "SoSFVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3s___ne__" "', argument " "2"" of type '" "SoSFVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3s * >(argp2);
  result = (int)((SoSFVec3s const *)arg1)->operator !=((SoSFVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3s_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec3s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_setValue" "', argument " "1"" of type '" "SoSFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec3s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec3s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec3s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3s_setValue" "', argument " "1"" of type '" "SoSFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3s_setValue" "', argument " "2"" of type '" "short const [3]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec3s_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFVec3s_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec3s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec3s::setValue(SbVec3s const &)\n"
    "    SoSFVec3s::setValue(short,short,short)\n"
    "    SoSFVec3s::setValue(short const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec3s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec3s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec3s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec3i32", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec3i32 *)new SoSFVec3i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec3i32" "', argument " "1"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec3i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec3i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_getTypeId" "', argument " "1"" of type '" "SoSFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  result = ((SoSFVec3i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_copyFrom" "', argument " "1"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_isSame" "', argument " "1"" of type '" "SoSFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec3i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_getValue" "', argument " "1"" of type '" "SoSFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  result = (SbVec3i32 *) &((SoSFVec3i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_setValue" "', argument " "1"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  (arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  SoSFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32___eq__" "', argument " "1"" of type '" "SoSFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32___eq__" "', argument " "2"" of type '" "SoSFVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3i32___eq__" "', argument " "2"" of type '" "SoSFVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3i32 * >(argp2);
  result = (int)((SoSFVec3i32 const *)arg1)->operator ==((SoSFVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  SoSFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32___ne__" "', argument " "1"" of type '" "SoSFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32___ne__" "', argument " "2"" of type '" "SoSFVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3i32___ne__" "', argument " "2"" of type '" "SoSFVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3i32 * >(argp2);
  result = (int)((SoSFVec3i32 const *)arg1)->operator !=((SoSFVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3i32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec3i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_setValue" "', argument " "1"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec3i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec3i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec3i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3i32_setValue" "', argument " "1"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3i32_setValue" "', argument " "2"" of type '" "int32_t const [3]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec3i32_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFVec3i32_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec3i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec3i32::setValue(SbVec3i32 const &)\n"
    "    SoSFVec3i32::setValue(int32_t,int32_t,int32_t)\n"
    "    SoSFVec3i32::setValue(int32_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec3i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec3i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec3i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec3d", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec3d *)new SoSFVec3d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec3d" "', argument " "1"" of type '" "SoSFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec3d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec3d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_getTypeId" "', argument " "1"" of type '" "SoSFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  result = ((SoSFVec3d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_copyFrom" "', argument " "1"" of type '" "SoSFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_isSame" "', argument " "1"" of type '" "SoSFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec3d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_getValue" "', argument " "1"" of type '" "SoSFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  result = (SbVec3d *) &((SoSFVec3d const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_setValue" "', argument " "1"" of type '" "SoSFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  SoSFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d___eq__" "', argument " "1"" of type '" "SoSFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d___eq__" "', argument " "2"" of type '" "SoSFVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3d___eq__" "', argument " "2"" of type '" "SoSFVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3d * >(argp2);
  result = (int)((SoSFVec3d const *)arg1)->operator ==((SoSFVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  SoSFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d___ne__" "', argument " "1"" of type '" "SoSFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d___ne__" "', argument " "2"" of type '" "SoSFVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec3d___ne__" "', argument " "2"" of type '" "SoSFVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3d * >(argp2);
  result = (int)((SoSFVec3d const *)arg1)->operator !=((SoSFVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec3d_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec3d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_setValue" "', argument " "1"" of type '" "SoSFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec3d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec3d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec3d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec3d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec3d_setValue" "', argument " "1"" of type '" "SoSFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec3d_setValue" "', argument " "2"" of type '" "double const [3]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec3d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec3d_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec3d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSFVec3d_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec3d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec3d::setValue(SbVec3d const &)\n"
    "    SoSFVec3d::setValue(double,double,double)\n"
    "    SoSFVec3d::setValue(double const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec3d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec3d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4b *)new SbVec4b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t *arg1 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "int8_t const [4]""'"); 
  } 
  arg1 = reinterpret_cast< int8_t * >(argp1);
  result = (SbVec4b *)new SbVec4b((int8_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int8_t arg1 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  signed char val1 ;
  int ecode1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_signed_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "int8_t""'");
  } 
  arg1 = static_cast< int8_t >(val1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4b" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4b" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4b" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  result = (SbVec4b *)new SbVec4b(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  result = (SbVec4b *)new SbVec4b((SbVec4ub const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (SbVec4b *)new SbVec4b((SbVec4s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (SbVec4b *)new SbVec4b((SbVec4i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (SbVec4b *)new SbVec4b((SbVec4f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4b" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (SbVec4b *)new SbVec4b((SbVec4d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4b(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4b", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4b__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_signed_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4b__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_signed_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4b__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4b'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4b::SbVec4b()\n"
    "    SbVec4b::SbVec4b(int8_t const [4])\n"
    "    SbVec4b::SbVec4b(int8_t,int8_t,int8_t,int8_t)\n"
    "    SbVec4b::SbVec4b(SbVec4ub const &)\n"
    "    SbVec4b::SbVec4b(SbVec4s const &)\n"
    "    SbVec4b::SbVec4b(SbVec4i32 const &)\n"
    "    SbVec4b::SbVec4b(SbVec4f const &)\n"
    "    SbVec4b::SbVec4b(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "int8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  int8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  signed char val5 ;
  int ecode5 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  ecode5 = SWIG_AsVal_signed_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4b_setValue" "', argument " "5"" of type '" "int8_t""'");
  } 
  arg5 = static_cast< int8_t >(val5);
  result = (SbVec4b *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ub * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((SbVec4ub const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_setValue" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4b *) &(arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4b_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4b_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_signed_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4b_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4b::setValue(int8_t const [4])\n"
    "    SbVec4b::setValue(int8_t,int8_t,int8_t,int8_t)\n"
    "    SbVec4b::setValue(SbVec4ub const &)\n"
    "    SbVec4b::setValue(SbVec4s const &)\n"
    "    SbVec4b::setValue(SbVec4i32 const &)\n"
    "    SbVec4b::setValue(SbVec4f const &)\n"
    "    SbVec4b::setValue(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4b_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int8_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_getValue" "', argument " "1"" of type '" "SbVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (int8_t *)((SbVec4b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  int8_t *arg2 = 0 ;
  int8_t *arg3 = 0 ;
  int8_t *arg4 = 0 ;
  int8_t *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_getValue" "', argument " "1"" of type '" "SbVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_getValue" "', argument " "2"" of type '" "int8_t &""'"); 
  }
  arg2 = reinterpret_cast< int8_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec4b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_getValue" "', argument " "3"" of type '" "int8_t &""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec4b_getValue" "', argument " "4"" of type '" "int8_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_getValue" "', argument " "4"" of type '" "int8_t &""'"); 
  }
  arg4 = reinterpret_cast< int8_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_signed_char,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4b_getValue" "', argument " "5"" of type '" "int8_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_getValue" "', argument " "5"" of type '" "int8_t &""'"); 
  }
  arg5 = reinterpret_cast< int8_t * >(argp5);
  ((SbVec4b const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4b_getValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4b_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_signed_char, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec4b_getValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4b_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4b::getValue() const\n"
    "    SbVec4b::getValue(int8_t &,int8_t &,int8_t &,int8_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4b_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4b_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_dot" "', argument " "1"" of type '" "SbVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b_dot" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b_dot" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int32_t)((SbVec4b const *)arg1)->dot(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b_negate" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___imul__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4b___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___imul__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4b___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4b *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4b___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4b___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4b___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4b___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4b::operator *=(int)\n"
    "    SbVec4b::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4b___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___itruediv__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4b___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___itruediv__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4b___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4b *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4b___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4b___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4b___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4b___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4b::operator /=(int)\n"
    "    SbVec4b::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4b___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4b___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___iadd__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b___iadd__" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b___iadd__" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec4b *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4b___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___isub__" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4b___isub__" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4b___isub__" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec4b *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4b___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4b___neg__" "', argument " "1"" of type '" "SbVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = ((SbVec4b const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4b(result)), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4b" "', argument " "1"" of type '" "SbVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4b", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4b *)new SoSFVec4b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4b" "', argument " "1"" of type '" "SoSFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_getTypeId" "', argument " "1"" of type '" "SoSFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  result = ((SoSFVec4b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_copyFrom" "', argument " "1"" of type '" "SoSFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_isSame" "', argument " "1"" of type '" "SoSFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4b result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_getValue" "', argument " "1"" of type '" "SoSFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  result = ((SoSFVec4b const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj((new SbVec4b(result)), SWIGTYPE_p_SbVec4b, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_setValue" "', argument " "1"" of type '" "SoSFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b_setValue" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4b_setValue" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  SoSFVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b___eq__" "', argument " "1"" of type '" "SoSFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b___eq__" "', argument " "2"" of type '" "SoSFVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4b___eq__" "', argument " "2"" of type '" "SoSFVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4b * >(argp2);
  result = (int)((SoSFVec4b const *)arg1)->operator ==((SoSFVec4b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  SoSFVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b___ne__" "', argument " "1"" of type '" "SoSFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b___ne__" "', argument " "2"" of type '" "SoSFVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4b___ne__" "', argument " "2"" of type '" "SoSFVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4b * >(argp2);
  result = (int)((SoSFVec4b const *)arg1)->operator !=((SoSFVec4b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4b_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  int8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  signed char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_setValue" "', argument " "1"" of type '" "SoSFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  ecode5 = SWIG_AsVal_signed_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4b_setValue" "', argument " "5"" of type '" "int8_t""'");
  } 
  arg5 = static_cast< int8_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4b_setValue" "', argument " "1"" of type '" "SoSFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4b_setValue" "', argument " "2"" of type '" "int8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4b_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_signed_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4b_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4b::setValue(SbVec4b)\n"
    "    SoSFVec4b::setValue(int8_t,int8_t,int8_t,int8_t)\n"
    "    SoSFVec4b::setValue(int8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4ub *)new SbVec4ub();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint8_t *arg1 = (uint8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "uint8_t const [4]""'"); 
  } 
  arg1 = reinterpret_cast< uint8_t * >(argp1);
  result = (SbVec4ub *)new SbVec4ub((uint8_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint8_t arg1 ;
  uint8_t arg2 ;
  uint8_t arg3 ;
  uint8_t arg4 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "uint8_t""'");
  } 
  arg1 = static_cast< uint8_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4ub" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4ub" "', argument " "3"" of type '" "uint8_t""'");
  } 
  arg3 = static_cast< uint8_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4ub" "', argument " "4"" of type '" "uint8_t""'");
  } 
  arg4 = static_cast< uint8_t >(val4);
  result = (SbVec4ub *)new SbVec4ub(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (SbVec4ub *)new SbVec4ub((SbVec4b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  result = (SbVec4ub *)new SbVec4ub((SbVec4us const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ub" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  result = (SbVec4ub *)new SbVec4ub((SbVec4ui32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4ub", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4ub__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ub__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ub__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ub__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ub__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4ub__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4ub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ub::SbVec4ub()\n"
    "    SbVec4ub::SbVec4ub(uint8_t const [4])\n"
    "    SbVec4ub::SbVec4ub(uint8_t,uint8_t,uint8_t,uint8_t)\n"
    "    SbVec4ub::SbVec4ub(SbVec4b const &)\n"
    "    SbVec4ub::SbVec4ub(SbVec4us const &)\n"
    "    SbVec4ub::SbVec4ub(SbVec4ui32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  uint8_t *arg2 = (uint8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_setValue" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "uint8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  result = (SbVec4ub *) &(arg1)->setValue((uint8_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  uint8_t arg2 ;
  uint8_t arg3 ;
  uint8_t arg4 ;
  uint8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_setValue" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4ub_setValue" "', argument " "3"" of type '" "uint8_t""'");
  } 
  arg3 = static_cast< uint8_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4ub_setValue" "', argument " "4"" of type '" "uint8_t""'");
  } 
  arg4 = static_cast< uint8_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4ub_setValue" "', argument " "5"" of type '" "uint8_t""'");
  } 
  arg5 = static_cast< uint8_t >(val5);
  result = (SbVec4ub *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_setValue" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4b * >(argp2);
  result = (SbVec4ub *) &(arg1)->setValue((SbVec4b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_setValue" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (SbVec4ub *) &(arg1)->setValue((SbVec4us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_setValue" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (SbVec4ub *) &(arg1)->setValue((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ub_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ub_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ub_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ub_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ub_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4ub_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ub_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ub::setValue(uint8_t const [4])\n"
    "    SbVec4ub::setValue(uint8_t,uint8_t,uint8_t,uint8_t)\n"
    "    SbVec4ub::setValue(SbVec4b const &)\n"
    "    SbVec4ub::setValue(SbVec4us const &)\n"
    "    SbVec4ub::setValue(SbVec4ui32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_getValue" "', argument " "1"" of type '" "SbVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  result = (uint8_t *)((SbVec4ub const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  uint8_t *arg2 = 0 ;
  uint8_t *arg3 = 0 ;
  uint8_t *arg4 = 0 ;
  uint8_t *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_getValue" "', argument " "1"" of type '" "SbVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_getValue" "', argument " "2"" of type '" "uint8_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_getValue" "', argument " "2"" of type '" "uint8_t &""'"); 
  }
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec4ub_getValue" "', argument " "3"" of type '" "uint8_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_getValue" "', argument " "3"" of type '" "uint8_t &""'"); 
  }
  arg3 = reinterpret_cast< uint8_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec4ub_getValue" "', argument " "4"" of type '" "uint8_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_getValue" "', argument " "4"" of type '" "uint8_t &""'"); 
  }
  arg4 = reinterpret_cast< uint8_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4ub_getValue" "', argument " "5"" of type '" "uint8_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_getValue" "', argument " "5"" of type '" "uint8_t &""'"); 
  }
  arg5 = reinterpret_cast< uint8_t * >(argp5);
  ((SbVec4ub const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ub_getValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4ub_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec4ub_getValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ub_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ub::getValue() const\n"
    "    SbVec4ub::getValue(uint8_t &,uint8_t &,uint8_t &,uint8_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ub_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_dot" "', argument " "1"" of type '" "SbVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub_dot" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub_dot" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int32_t)((SbVec4ub const *)arg1)->dot(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub_negate" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___imul__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ub___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ub *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___imul__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ub___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4ub *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ub___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ub___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ub___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ub___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ub::operator *=(int)\n"
    "    SbVec4ub::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___itruediv__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ub___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ub *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___itruediv__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ub___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4ub *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ub___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ub___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ub___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ub___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ub::operator /=(int)\n"
    "    SbVec4ub::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ub___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___iadd__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub___iadd__" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub___iadd__" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec4ub *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ub___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___isub__" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ub___isub__" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ub___isub__" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbVec4ub *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ub___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ub result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ub___neg__" "', argument " "1"" of type '" "SbVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  result = ((SbVec4ub const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4ub(result)), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4ub(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4ub" "', argument " "1"" of type '" "SbVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4ub_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4ub, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4ub_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4ub(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4ub", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4ub *)new SoSFVec4ub();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4ub(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4ub" "', argument " "1"" of type '" "SoSFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4ub::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4ub::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_getTypeId" "', argument " "1"" of type '" "SoSFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  result = ((SoSFVec4ub const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_copyFrom" "', argument " "1"" of type '" "SoSFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ub_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_isSame" "', argument " "1"" of type '" "SoSFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ub_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4ub const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ub result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_getValue" "', argument " "1"" of type '" "SoSFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  result = ((SoSFVec4ub const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj((new SbVec4ub(result)), SWIGTYPE_p_SbVec4ub, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_setValue" "', argument " "1"" of type '" "SoSFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  SoSFVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub___eq__" "', argument " "1"" of type '" "SoSFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub___eq__" "', argument " "2"" of type '" "SoSFVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ub___eq__" "', argument " "2"" of type '" "SoSFVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4ub * >(argp2);
  result = (int)((SoSFVec4ub const *)arg1)->operator ==((SoSFVec4ub const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  SoSFVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub___ne__" "', argument " "1"" of type '" "SoSFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub___ne__" "', argument " "2"" of type '" "SoSFVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ub___ne__" "', argument " "2"" of type '" "SoSFVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4ub * >(argp2);
  result = (int)((SoSFVec4ub const *)arg1)->operator !=((SoSFVec4ub const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ub_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4ub::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  uint8_t arg2 ;
  uint8_t arg3 ;
  uint8_t arg4 ;
  uint8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_setValue" "', argument " "1"" of type '" "SoSFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4ub_setValue" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4ub_setValue" "', argument " "3"" of type '" "uint8_t""'");
  } 
  arg3 = static_cast< uint8_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4ub_setValue" "', argument " "4"" of type '" "uint8_t""'");
  } 
  arg4 = static_cast< uint8_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4ub_setValue" "', argument " "5"" of type '" "uint8_t""'");
  } 
  arg5 = static_cast< uint8_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ub *arg1 = 0 ;
  uint8_t *arg2 = (uint8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ub_setValue" "', argument " "1"" of type '" "SoSFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ub_setValue" "', argument " "2"" of type '" "uint8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  (arg1)->setValue((uint8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ub_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4ub_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4ub_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4ub_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4ub_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4ub_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4ub::setValue(SbVec4ub)\n"
    "    SoSFVec4ub::setValue(uint8_t,uint8_t,uint8_t,uint8_t)\n"
    "    SoSFVec4ub::setValue(uint8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4ub_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4ub, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4ub_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4s *)new SbVec4s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short *arg1 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "short const [4]""'"); 
  } 
  arg1 = reinterpret_cast< short * >(argp1);
  result = (SbVec4s *)new SbVec4s((short const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short arg1 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short val1 ;
  int ecode1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "short""'");
  } 
  arg1 = static_cast< short >(val1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4s" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4s" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4s" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  result = (SbVec4s *)new SbVec4s(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  result = (SbVec4s *)new SbVec4s((SbVec4us const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (SbVec4s *)new SbVec4s((SbVec4b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (SbVec4s *)new SbVec4s((SbVec4i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (SbVec4s *)new SbVec4s((SbVec4f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4s" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (SbVec4s *)new SbVec4s((SbVec4d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4s(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4s", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4s__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_short, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4s__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4s__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4s'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4s::SbVec4s()\n"
    "    SbVec4s::SbVec4s(short const [4])\n"
    "    SbVec4s::SbVec4s(short,short,short,short)\n"
    "    SbVec4s::SbVec4s(SbVec4us const &)\n"
    "    SbVec4s::SbVec4s(SbVec4b const &)\n"
    "    SbVec4s::SbVec4s(SbVec4i32 const &)\n"
    "    SbVec4s::SbVec4s(SbVec4f const &)\n"
    "    SbVec4s::SbVec4s(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4s_setValue" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  result = (SbVec4s *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4b * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_setValue" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4s *) &(arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4s_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_setValue__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4s_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4s::setValue(short const [4])\n"
    "    SbVec4s::setValue(short,short,short,short)\n"
    "    SbVec4s::setValue(SbVec4s const &)\n"
    "    SbVec4s::setValue(SbVec4us const &)\n"
    "    SbVec4s::setValue(SbVec4b const &)\n"
    "    SbVec4s::setValue(SbVec4i32 const &)\n"
    "    SbVec4s::setValue(SbVec4f const &)\n"
    "    SbVec4s::setValue(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4s_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_getValue" "', argument " "1"" of type '" "SbVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (short *)((SbVec4s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  short *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short temp2 ;
  int res2 = SWIG_TMPOBJ ;
  short temp3 ;
  int res3 = SWIG_TMPOBJ ;
  short temp4 ;
  int res4 = SWIG_TMPOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_getValue" "', argument " "1"" of type '" "SbVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res5 = SWIG_ConvertPtr(swig_obj[1], &argp5, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4s_getValue" "', argument " "5"" of type '" "short &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_getValue" "', argument " "5"" of type '" "short &""'"); 
  }
  arg5 = reinterpret_cast< short * >(argp5);
  ((SbVec4s const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg2)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_short, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_short, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_short((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_short, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4s_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4s_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4s_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4s_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4s::getValue() const\n"
    "    SbVec4s::getValue(short &,short &,short &,short &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4s_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4s_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_dot" "', argument " "1"" of type '" "SbVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s_dot" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s_dot" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (int32_t)((SbVec4s const *)arg1)->dot((SbVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s_negate" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___imul__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4s___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___imul__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4s___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4s *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4s___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4s___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4s___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4s___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4s::operator *=(int)\n"
    "    SbVec4s::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4s___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___itruediv__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4s___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___itruediv__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4s___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4s *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4s___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4s___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4s___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4s___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4s::operator /=(int)\n"
    "    SbVec4s::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4s___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4s___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___iadd__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s___iadd__" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s___iadd__" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4s *) &(arg1)->operator +=((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4s___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___isub__" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4s___isub__" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4s___isub__" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4s *) &(arg1)->operator -=((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4s___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4s___neg__" "', argument " "1"" of type '" "SbVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = ((SbVec4s const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4s(result)), SWIGTYPE_p_SbVec4s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4s" "', argument " "1"" of type '" "SbVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4s", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4s *)new SoSFVec4s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4s" "', argument " "1"" of type '" "SoSFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_getTypeId" "', argument " "1"" of type '" "SoSFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  result = ((SoSFVec4s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_copyFrom" "', argument " "1"" of type '" "SoSFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_isSame" "', argument " "1"" of type '" "SoSFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_getValue" "', argument " "1"" of type '" "SoSFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  result = (SbVec4s *) &((SoSFVec4s const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_setValue" "', argument " "1"" of type '" "SoSFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  (arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  SoSFVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s___eq__" "', argument " "1"" of type '" "SoSFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s___eq__" "', argument " "2"" of type '" "SoSFVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4s___eq__" "', argument " "2"" of type '" "SoSFVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4s * >(argp2);
  result = (int)((SoSFVec4s const *)arg1)->operator ==((SoSFVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  SoSFVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s___ne__" "', argument " "1"" of type '" "SoSFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s___ne__" "', argument " "2"" of type '" "SoSFVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4s___ne__" "', argument " "2"" of type '" "SoSFVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4s * >(argp2);
  result = (int)((SoSFVec4s const *)arg1)->operator !=((SoSFVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4s_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_setValue" "', argument " "1"" of type '" "SoSFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4s_setValue" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4s_setValue" "', argument " "1"" of type '" "SoSFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4s_setValue" "', argument " "2"" of type '" "short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4s_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4s_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4s::setValue(SbVec4s const &)\n"
    "    SoSFVec4s::setValue(short,short,short,short)\n"
    "    SoSFVec4s::setValue(short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4us *)new SbVec4us();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned short *arg1 = (unsigned short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4us" "', argument " "1"" of type '" "unsigned short const [4]""'"); 
  } 
  arg1 = reinterpret_cast< unsigned short * >(argp1);
  result = (SbVec4us *)new SbVec4us((unsigned short const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned short arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4us" "', argument " "1"" of type '" "unsigned short""'");
  } 
  arg1 = static_cast< unsigned short >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4us" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4us" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4us" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  result = (SbVec4us *)new SbVec4us(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (SbVec4us *)new SbVec4us((SbVec4s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  result = (SbVec4us *)new SbVec4us((SbVec4ub const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4us" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  result = (SbVec4us *)new SbVec4us((SbVec4ui32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4us(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4us", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4us__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4us__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4us__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4us__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4us__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4us__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4us'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4us::SbVec4us()\n"
    "    SbVec4us::SbVec4us(unsigned short const [4])\n"
    "    SbVec4us::SbVec4us(unsigned short,unsigned short,unsigned short,unsigned short)\n"
    "    SbVec4us::SbVec4us(SbVec4s const &)\n"
    "    SbVec4us::SbVec4us(SbVec4ub const &)\n"
    "    SbVec4us::SbVec4us(SbVec4ui32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  unsigned short *arg2 = (unsigned short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_setValue" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "unsigned short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  result = (SbVec4us *) &(arg1)->setValue((unsigned short const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_setValue" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4us_setValue" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4us_setValue" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4us_setValue" "', argument " "5"" of type '" "unsigned short""'");
  } 
  arg5 = static_cast< unsigned short >(val5);
  result = (SbVec4us *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_setValue" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4us *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_setValue" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ub * >(argp2);
  result = (SbVec4us *) &(arg1)->setValue((SbVec4ub const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_setValue" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (SbVec4us *) &(arg1)->setValue((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4us_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4us_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4us_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4us_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4us_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4us_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4us_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4us::setValue(unsigned short const [4])\n"
    "    SbVec4us::setValue(unsigned short,unsigned short,unsigned short,unsigned short)\n"
    "    SbVec4us::setValue(SbVec4s const &)\n"
    "    SbVec4us::setValue(SbVec4ub const &)\n"
    "    SbVec4us::setValue(SbVec4ui32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4us_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_getValue" "', argument " "1"" of type '" "SbVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  result = (unsigned short *)((SbVec4us const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  unsigned short *arg2 = 0 ;
  unsigned short *arg3 = 0 ;
  unsigned short *arg4 = 0 ;
  unsigned short *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_getValue" "', argument " "1"" of type '" "SbVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_getValue" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_getValue" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec4us_getValue" "', argument " "3"" of type '" "unsigned short &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_getValue" "', argument " "3"" of type '" "unsigned short &""'"); 
  }
  arg3 = reinterpret_cast< unsigned short * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec4us_getValue" "', argument " "4"" of type '" "unsigned short &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_getValue" "', argument " "4"" of type '" "unsigned short &""'"); 
  }
  arg4 = reinterpret_cast< unsigned short * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4us_getValue" "', argument " "5"" of type '" "unsigned short &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_getValue" "', argument " "5"" of type '" "unsigned short &""'"); 
  }
  arg5 = reinterpret_cast< unsigned short * >(argp5);
  ((SbVec4us const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4us_getValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4us_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec4us_getValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4us_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4us::getValue() const\n"
    "    SbVec4us::getValue(unsigned short &,unsigned short &,unsigned short &,unsigned short &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4us_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4us_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_dot" "', argument " "1"" of type '" "SbVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us_dot" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us_dot" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (int32_t)((SbVec4us const *)arg1)->dot((SbVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us_negate" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___imul__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4us___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4us *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___imul__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4us___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4us *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4us___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4us___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4us___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4us___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4us::operator *=(int)\n"
    "    SbVec4us::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4us___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___itruediv__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4us___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4us *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___itruediv__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4us___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4us *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4us___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4us___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4us___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4us___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4us::operator /=(int)\n"
    "    SbVec4us::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4us___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4us___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___iadd__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us___iadd__" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us___iadd__" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (SbVec4us *) &(arg1)->operator +=((SbVec4us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4us___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___isub__" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4us___isub__" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4us___isub__" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (SbVec4us *) &(arg1)->operator -=((SbVec4us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4us___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4us result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4us___neg__" "', argument " "1"" of type '" "SbVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  result = ((SbVec4us const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4us(result)), SWIGTYPE_p_SbVec4us, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4us(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4us" "', argument " "1"" of type '" "SbVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4us_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4us, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4us_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4us(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4us", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4us *)new SoSFVec4us();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4us(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4us" "', argument " "1"" of type '" "SoSFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4us::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4us::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_getTypeId" "', argument " "1"" of type '" "SoSFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  result = ((SoSFVec4us const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_copyFrom" "', argument " "1"" of type '" "SoSFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4us_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_isSame" "', argument " "1"" of type '" "SoSFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4us_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4us const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_getValue" "', argument " "1"" of type '" "SoSFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  result = (SbVec4us *) &((SoSFVec4us const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_setValue" "', argument " "1"" of type '" "SoSFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4us_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  (arg1)->setValue((SbVec4us const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  SoSFVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us___eq__" "', argument " "1"" of type '" "SoSFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us___eq__" "', argument " "2"" of type '" "SoSFVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4us___eq__" "', argument " "2"" of type '" "SoSFVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4us * >(argp2);
  result = (int)((SoSFVec4us const *)arg1)->operator ==((SoSFVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  SoSFVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us___ne__" "', argument " "1"" of type '" "SoSFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us___ne__" "', argument " "2"" of type '" "SoSFVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4us___ne__" "', argument " "2"" of type '" "SoSFVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4us * >(argp2);
  result = (int)((SoSFVec4us const *)arg1)->operator !=((SoSFVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4us_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4us::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_setValue" "', argument " "1"" of type '" "SoSFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4us_setValue" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4us_setValue" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4us_setValue" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4us_setValue" "', argument " "5"" of type '" "unsigned short""'");
  } 
  arg5 = static_cast< unsigned short >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4us *arg1 = 0 ;
  unsigned short *arg2 = (unsigned short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4us_setValue" "', argument " "1"" of type '" "SoSFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4us_setValue" "', argument " "2"" of type '" "unsigned short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  (arg1)->setValue((unsigned short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4us_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4us_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4us_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4us_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4us_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4us_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4us::setValue(SbVec4us const &)\n"
    "    SoSFVec4us::setValue(unsigned short,unsigned short,unsigned short,unsigned short)\n"
    "    SoSFVec4us::setValue(unsigned short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4us_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4us, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4us_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4i32 *)new SbVec4i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t *arg1 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "int32_t const [4]""'"); 
  } 
  arg1 = reinterpret_cast< int32_t * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((int32_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int32_t arg1 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "int32_t""'");
  } 
  arg1 = static_cast< int32_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4i32" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4i32" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4i32" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  result = (SbVec4i32 *)new SbVec4i32(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((SbVec4ui32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((SbVec4b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((SbVec4s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((SbVec4f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4i32" "', argument " "1"" of type '" "SbVec4d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (SbVec4i32 *)new SbVec4i32((SbVec4d const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4i32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4i32", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4i32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4i32__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4i32__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4i32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4i32::SbVec4i32()\n"
    "    SbVec4i32::SbVec4i32(int32_t const [4])\n"
    "    SbVec4i32::SbVec4i32(int32_t,int32_t,int32_t,int32_t)\n"
    "    SbVec4i32::SbVec4i32(SbVec4ui32 const &)\n"
    "    SbVec4i32::SbVec4i32(SbVec4b const &)\n"
    "    SbVec4i32::SbVec4i32(SbVec4s const &)\n"
    "    SbVec4i32::SbVec4i32(SbVec4f const &)\n"
    "    SbVec4i32::SbVec4i32(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "int32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4i32_setValue" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  result = (SbVec4i32 *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4b * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((SbVec4b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_setValue" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4i32 *) &(arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4i32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4i32_setValue__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4i32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4i32::setValue(int32_t const [4])\n"
    "    SbVec4i32::setValue(int32_t,int32_t,int32_t,int32_t)\n"
    "    SbVec4i32::setValue(SbVec4ui32 const &)\n"
    "    SbVec4i32::setValue(SbVec4b const &)\n"
    "    SbVec4i32::setValue(SbVec4s const &)\n"
    "    SbVec4i32::setValue(SbVec4f const &)\n"
    "    SbVec4i32::setValue(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_getValue" "', argument " "1"" of type '" "SbVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (int32_t *)((SbVec4i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  int32_t *arg4 = 0 ;
  int32_t *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_getValue" "', argument " "1"" of type '" "SbVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_getValue" "', argument " "2"" of type '" "int32_t &""'"); 
  }
  arg2 = reinterpret_cast< int32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec4i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_getValue" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec4i32_getValue" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_getValue" "', argument " "4"" of type '" "int32_t &""'"); 
  }
  arg4 = reinterpret_cast< int32_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4i32_getValue" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_getValue" "', argument " "5"" of type '" "int32_t &""'"); 
  }
  arg5 = reinterpret_cast< int32_t * >(argp5);
  ((SbVec4i32 const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4i32_getValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4i32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec4i32_getValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4i32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4i32::getValue() const\n"
    "    SbVec4i32::getValue(int32_t &,int32_t &,int32_t &,int32_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4i32_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_dot" "', argument " "1"" of type '" "SbVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32_dot" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32_dot" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (int32_t)((SbVec4i32 const *)arg1)->dot((SbVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32_negate" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___imul__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4i32___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___imul__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4i32___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4i32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4i32___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4i32___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4i32___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4i32___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4i32::operator *=(int)\n"
    "    SbVec4i32::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___itruediv__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4i32___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___itruediv__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4i32___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4i32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4i32___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4i32___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4i32___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4i32___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4i32::operator /=(int)\n"
    "    SbVec4i32::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4i32___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___iadd__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32___iadd__" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32___iadd__" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4i32 *) &(arg1)->operator +=((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4i32___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___isub__" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4i32___isub__" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4i32___isub__" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4i32 *) &(arg1)->operator -=((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4i32___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4i32 result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4i32___neg__" "', argument " "1"" of type '" "SbVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = ((SbVec4i32 const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4i32(result)), SWIGTYPE_p_SbVec4i32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4i32" "', argument " "1"" of type '" "SbVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4i32", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4i32 *)new SoSFVec4i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4i32" "', argument " "1"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_getTypeId" "', argument " "1"" of type '" "SoSFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  result = ((SoSFVec4i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_copyFrom" "', argument " "1"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_isSame" "', argument " "1"" of type '" "SoSFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_getValue" "', argument " "1"" of type '" "SoSFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  result = (SbVec4i32 *) &((SoSFVec4i32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_setValue" "', argument " "1"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4i32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  (arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  SoSFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32___eq__" "', argument " "1"" of type '" "SoSFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32___eq__" "', argument " "2"" of type '" "SoSFVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4i32___eq__" "', argument " "2"" of type '" "SoSFVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4i32 * >(argp2);
  result = (int)((SoSFVec4i32 const *)arg1)->operator ==((SoSFVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  SoSFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32___ne__" "', argument " "1"" of type '" "SoSFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32___ne__" "', argument " "2"" of type '" "SoSFVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4i32___ne__" "', argument " "2"" of type '" "SoSFVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4i32 * >(argp2);
  result = (int)((SoSFVec4i32 const *)arg1)->operator !=((SoSFVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4i32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_setValue" "', argument " "1"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4i32_setValue" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4i32_setValue" "', argument " "1"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4i32_setValue" "', argument " "2"" of type '" "int32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4i32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4i32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4i32::setValue(SbVec4i32 const &)\n"
    "    SoSFVec4i32::setValue(int32_t,int32_t,int32_t,int32_t)\n"
    "    SoSFVec4i32::setValue(int32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4ui32 *)new SbVec4ui32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t *arg1 = (uint32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "uint32_t const [4]""'"); 
  } 
  arg1 = reinterpret_cast< uint32_t * >(argp1);
  result = (SbVec4ui32 *)new SbVec4ui32((uint32_t const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4ui32" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4ui32" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4ui32" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  result = (SbVec4ui32 *)new SbVec4ui32(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (SbVec4ui32 *)new SbVec4ui32((SbVec4i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4ub const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ub * >(argp1);
  result = (SbVec4ui32 *)new SbVec4ui32((SbVec4ub const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4ui32" "', argument " "1"" of type '" "SbVec4us const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4us * >(argp1);
  result = (SbVec4ui32 *)new SbVec4ui32((SbVec4us const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4ui32(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4ui32", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4ui32__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ui32__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ui32__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ui32__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4ui32__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4ui32__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4ui32'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ui32::SbVec4ui32()\n"
    "    SbVec4ui32::SbVec4ui32(uint32_t const [4])\n"
    "    SbVec4ui32::SbVec4ui32(uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    SbVec4ui32::SbVec4ui32(SbVec4i32 const &)\n"
    "    SbVec4ui32::SbVec4ui32(SbVec4ub const &)\n"
    "    SbVec4ui32::SbVec4ui32(SbVec4us const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  uint32_t *arg2 = (uint32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_setValue" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint32_t * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->setValue((uint32_t const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_setValue" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4ui32_setValue" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4ui32_setValue" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4ui32_setValue" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  result = (SbVec4ui32 *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_setValue" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_setValue" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ub * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->setValue((SbVec4ub const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_setValue" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->setValue((SbVec4us const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ui32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ui32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ui32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ui32_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4ui32_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4ui32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ui32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ui32::setValue(uint32_t const [4])\n"
    "    SbVec4ui32::setValue(uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    SbVec4ui32::setValue(SbVec4i32 const &)\n"
    "    SbVec4ui32::setValue(SbVec4ub const &)\n"
    "    SbVec4ui32::setValue(SbVec4us const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_getValue" "', argument " "1"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  result = (uint32_t *)((SbVec4ui32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  uint32_t *arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  uint32_t *arg4 = 0 ;
  uint32_t *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_getValue" "', argument " "1"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_getValue" "', argument " "2"" of type '" "uint32_t &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_getValue" "', argument " "2"" of type '" "uint32_t &""'"); 
  }
  arg2 = reinterpret_cast< uint32_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec4ui32_getValue" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_getValue" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  arg3 = reinterpret_cast< uint32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbVec4ui32_getValue" "', argument " "4"" of type '" "uint32_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_getValue" "', argument " "4"" of type '" "uint32_t &""'"); 
  }
  arg4 = reinterpret_cast< uint32_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbVec4ui32_getValue" "', argument " "5"" of type '" "uint32_t &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_getValue" "', argument " "5"" of type '" "uint32_t &""'"); 
  }
  arg5 = reinterpret_cast< uint32_t * >(argp5);
  ((SbVec4ui32 const *)arg1)->getValue(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ui32_getValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbVec4ui32_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_int, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbVec4ui32_getValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ui32_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ui32::getValue() const\n"
    "    SbVec4ui32::getValue(uint32_t &,uint32_t &,uint32_t &,uint32_t &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ui32_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_dot" "', argument " "1"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32_dot" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32_dot" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (int32_t)((SbVec4ui32 const *)arg1)->dot((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32_negate" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___imul__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ui32___imul__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ui32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___imul__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ui32___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4ui32 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ui32___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ui32___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ui32___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ui32___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ui32::operator *=(int)\n"
    "    SbVec4ui32::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___itruediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___itruediv__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ui32___itruediv__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ui32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___itruediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___itruediv__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4ui32___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4ui32 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___itruediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4ui32___itruediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ui32___itruediv____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4ui32___itruediv____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4ui32___itruediv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4ui32::operator /=(int)\n"
    "    SbVec4ui32::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ui32___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___iadd__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32___iadd__" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32___iadd__" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->operator +=((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4ui32___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___isub__" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4ui32___isub__" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4ui32___isub__" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (SbVec4ui32 *) &(arg1)->operator -=((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4ui32___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ui32 result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4ui32___neg__" "', argument " "1"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  result = ((SbVec4ui32 const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4ui32(result)), SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4ui32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4ui32" "', argument " "1"" of type '" "SbVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4ui32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4ui32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4ui32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4ui32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4ui32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4ui32", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4ui32 *)new SoSFVec4ui32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4ui32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4ui32" "', argument " "1"" of type '" "SoSFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4ui32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4ui32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_getTypeId" "', argument " "1"" of type '" "SoSFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  result = ((SoSFVec4ui32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_copyFrom" "', argument " "1"" of type '" "SoSFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ui32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_isSame" "', argument " "1"" of type '" "SoSFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ui32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4ui32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_getValue" "', argument " "1"" of type '" "SoSFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  result = (SbVec4ui32 *) &((SoSFVec4ui32 const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_setValue" "', argument " "1"" of type '" "SoSFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  (arg1)->setValue((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  SoSFVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32___eq__" "', argument " "1"" of type '" "SoSFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32___eq__" "', argument " "2"" of type '" "SoSFVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ui32___eq__" "', argument " "2"" of type '" "SoSFVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4ui32 * >(argp2);
  result = (int)((SoSFVec4ui32 const *)arg1)->operator ==((SoSFVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  SoSFVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32___ne__" "', argument " "1"" of type '" "SoSFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32___ne__" "', argument " "2"" of type '" "SoSFVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4ui32___ne__" "', argument " "2"" of type '" "SoSFVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4ui32 * >(argp2);
  result = (int)((SoSFVec4ui32 const *)arg1)->operator !=((SoSFVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4ui32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_setValue" "', argument " "1"" of type '" "SoSFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4ui32_setValue" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4ui32_setValue" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4ui32_setValue" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4ui32 *arg1 = 0 ;
  uint32_t *arg2 = (uint32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4ui32_setValue" "', argument " "1"" of type '" "SoSFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint32_t * >(argp2);
  (arg1)->setValue((uint32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4ui32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4ui32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4ui32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4ui32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4ui32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4ui32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4ui32::setValue(SbVec4ui32 const &)\n"
    "    SoSFVec4ui32::setValue(uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    SoSFVec4ui32::setValue(uint32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4ui32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4ui32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4ui32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4f", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4f *)new SoSFVec4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4f" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4f::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_getTypeId" "', argument " "1"" of type '" "SoSFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  result = ((SoSFVec4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_copyFrom" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4f_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_isSame" "', argument " "1"" of type '" "SoSFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4f_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4f const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_getValue" "', argument " "1"" of type '" "SoSFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  result = (SbVec4f *) &((SoSFVec4f const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_setValue" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4f_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f___eq__" "', argument " "1"" of type '" "SoSFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f___eq__" "', argument " "2"" of type '" "SoSFVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4f___eq__" "', argument " "2"" of type '" "SoSFVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  result = (int)((SoSFVec4f const *)arg1)->operator ==((SoSFVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f___ne__" "', argument " "1"" of type '" "SoSFVec4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f___ne__" "', argument " "2"" of type '" "SoSFVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4f___ne__" "', argument " "2"" of type '" "SoSFVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  result = (int)((SoSFVec4f const *)arg1)->operator !=((SoSFVec4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4f_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_setValue" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4f_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4f_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4f_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4f_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[4] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_setValue" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  {
    convert_SbVec4f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4f *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4f_setValue" "', argument " "1"" of type '" "SoSFVec4f *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4f_setValue" "', argument " "2"" of type '" "SoSFVec4f const *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  SoSFVec4f_setValue__SWIG_3(arg1,(SoSFVec4f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4f_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4f_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4f_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr;
        _v = (PySequence_Check(argv[1]) && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_SoMFVec4f, 0) == -1) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSFVec4f_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoSFVec4f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4f_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4f_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4f_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4f::setValue(SbVec4f const &)\n"
    "    SoSFVec4f::setValue(float,float,float,float)\n"
    "    SoSFVec4f::setValue(float const [4])\n"
    "    SoSFVec4f::setValue(SoSFVec4f const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbVec4d *)new SbVec4d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = (double *)0 ;
  double temp1[4] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec4d_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbVec4d *)new SbVec4d((double const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbVec4d" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbVec4d" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbVec4d" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbVec4d" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (SbVec4d *)new SbVec4d(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4f * >(argp1);
  result = (SbVec4d *)new SbVec4d((SbVec4f const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4b const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4b * >(argp1);
  result = (SbVec4d *)new SbVec4d((SbVec4b const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4s const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4s * >(argp1);
  result = (SbVec4d *)new SbVec4d((SbVec4s const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbVec4d" "', argument " "1"" of type '" "SbVec4i32 const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec4i32 * >(argp1);
  result = (SbVec4d *)new SbVec4d((SbVec4i32 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbVec4d(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbVec4d", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbVec4d__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4d__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4d__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4d__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbVec4d__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0 ;
    }
    if (_v) {
      return _wrap_new_SbVec4d__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbVec4d__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbVec4d'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4d::SbVec4d()\n"
    "    SbVec4d::SbVec4d(double const [4])\n"
    "    SbVec4d::SbVec4d(double,double,double,double)\n"
    "    SbVec4d::SbVec4d(SbVec4f const &)\n"
    "    SbVec4d::SbVec4d(SbVec4b const &)\n"
    "    SbVec4d::SbVec4d(SbVec4s const &)\n"
    "    SbVec4d::SbVec4d(SbVec4i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  {
    convert_SbVec4d_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbVec4d *) &(arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbVec4d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbVec4d_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (SbVec4d *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  result = (SbVec4d *) &(arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4b * >(argp2);
  result = (SbVec4d *) &(arg1)->setValue((SbVec4b const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (SbVec4d *) &(arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_setValue" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (SbVec4d *) &(arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4d_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4d_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4d_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4d_setValue__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0 ;
      }
      if (_v) {
        return _wrap_SbVec4d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbVec4d_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbVec4d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbVec4d::setValue(double const [4])\n"
    "    SbVec4d::setValue(double,double,double,double)\n"
    "    SbVec4d::setValue(SbVec4f const &)\n"
    "    SbVec4d::setValue(SbVec4b const &)\n"
    "    SbVec4d::setValue(SbVec4s const &)\n"
    "    SbVec4d::setValue(SbVec4i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbVec4d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_getValue" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (double *)((SbVec4d const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_dot" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_dot" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_dot" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (double)((SbVec4d const *)arg1)->dot((SbVec4d const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_equals" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_equals" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_equals" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4d_equals" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbBool)((SbVec4d const *)arg1)->equals((SbVec4d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_getReal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d_getReal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_getReal" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d_getReal" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d_getReal" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  ((SbVec4d const *)arg1)->getReal(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_length" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (double)((SbVec4d const *)arg1)->length();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_sqrLength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_sqrLength" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (double)((SbVec4d const *)arg1)->sqrLength();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_negate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_negate" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  (arg1)->negate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_normalize" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = (double)(arg1)->normalize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___imul__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4d *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___itruediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___itruediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___itruediv__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___itruediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbVec4d *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___iadd__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___iadd__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___iadd__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4d *) &(arg1)->operator +=((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___isub__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___isub__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___isub__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (SbVec4d *) &(arg1)->operator -=((SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4d result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___neg__" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  result = ((SbVec4d const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d_output" "', argument " "1"" of type '" "SbVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbVec4d const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___add__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___add__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___add__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = SbVec4d___add__(arg1,(SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___sub__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___sub__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___sub__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = SbVec4d___sub__(arg1,(SbVec4d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbVec4d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___mul__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec4d___mul____SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___mul__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = SbVec4d___mul____SWIG_1(arg1,(SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbVec4d___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbVec4d___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbVec4d___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___rmul__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec4d___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___div__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec4d___div__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___truediv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___truediv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___truediv__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___truediv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbVec4d___truediv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4d(result)), SWIGTYPE_p_SbVec4d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___eq__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___eq__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___eq__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (int)SbVec4d___eq__(arg1,(SbVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbVec4d___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___nq__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec4d___nq__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbVec4d___nq__" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (int)SbVec4d___nq__(arg1,(SbVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___getitem__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)SbVec4d___getitem__(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec4d___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec4d___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec4d___setitem__" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec4d___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec4d___setitem__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  SbVec4d___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec4d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec4d" "', argument " "1"" of type '" "SbVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SbVec4d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec4d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec4d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec4d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSFVec4d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSFVec4d", 0, 0, 0)) SWIG_fail;
  result = (SoSFVec4d *)new SoSFVec4d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSFVec4d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSFVec4d" "', argument " "1"" of type '" "SoSFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoSFVec4d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSFVec4d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_getTypeId" "', argument " "1"" of type '" "SoSFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  result = ((SoSFVec4d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_copyFrom" "', argument " "1"" of type '" "SoSFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_isSame" "', argument " "1"" of type '" "SoSFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoSFVec4d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_getValue" "', argument " "1"" of type '" "SoSFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  result = (SbVec4d *) &((SoSFVec4d const *)arg1)->getValue();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_setValue" "', argument " "1"" of type '" "SoSFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4d_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  (arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  SoSFVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d___eq__" "', argument " "1"" of type '" "SoSFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d___eq__" "', argument " "2"" of type '" "SoSFVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4d___eq__" "', argument " "2"" of type '" "SoSFVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4d * >(argp2);
  result = (int)((SoSFVec4d const *)arg1)->operator ==((SoSFVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  SoSFVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d___ne__" "', argument " "1"" of type '" "SoSFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoSFVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d___ne__" "', argument " "2"" of type '" "SoSFVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSFVec4d___ne__" "', argument " "2"" of type '" "SoSFVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4d * >(argp2);
  result = (int)((SoSFVec4d const *)arg1)->operator !=((SoSFVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSFVec4d_initClass", 0, 0, 0)) SWIG_fail;
  SoSFVec4d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_setValue" "', argument " "1"" of type '" "SoSFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSFVec4d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSFVec4d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSFVec4d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSFVec4d_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSFVec4d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSFVec4d_setValue" "', argument " "1"" of type '" "SoSFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoSFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSFVec4d_setValue" "', argument " "2"" of type '" "double const [4]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSFVec4d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSFVec4d_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSFVec4d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSFVec4d_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSFVec4d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSFVec4d::setValue(SbVec4d const &)\n"
    "    SoSFVec4d::setValue(double,double,double,double)\n"
    "    SoSFVec4d::setValue(double const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoSFVec4d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSFVec4d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSFVec4d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFColor", 0, 0, 0)) SWIG_fail;
  result = (SoMFColor *)new SoMFColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFColor" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFColor::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFColor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_getTypeId" "', argument " "1"" of type '" "SoMFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  result = ((SoMFColor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_copyFrom" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_isSame" "', argument " "1"" of type '" "SoMFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFColor const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_find" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_find" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_find" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbColor const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_find" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_find" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_find" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  result = (int)(arg1)->find((SbColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColor_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFColor_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::find(SbColor const &,SbBool)\n"
    "    SoMFColor::find(SbColor const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1Value" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColor_set1Value" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_set1Value" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  (arg1)->set1Value(arg2,(SbColor const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setValue((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor___eq__" "', argument " "1"" of type '" "SoMFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor___eq__" "', argument " "2"" of type '" "SoMFColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor___eq__" "', argument " "2"" of type '" "SoMFColor const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  result = (SbBool)((SoMFColor const *)arg1)->operator ==((SoMFColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFColor___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor___ne__" "', argument " "1"" of type '" "SoMFColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor___ne__" "', argument " "2"" of type '" "SoMFColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor___ne__" "', argument " "2"" of type '" "SoMFColor const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  result = (SbBool)((SoMFColor const *)arg1)->operator !=((SoMFColor const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFColor_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_startEditing" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  result = (SbColor *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_finishEditing" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValuesPointer" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValuesPointer" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValuesPointer" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColor_setValuesPointer" "', argument " "3"" of type '" "SbColor const *""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbColor const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValuesPointer" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColor_setValuesPointer" "', argument " "3"" of type '" "SbColor *""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::setValuesPointer(int const,float const *)\n"
    "    SoMFColor::setValuesPointer(int const,float *)\n"
    "    SoMFColor::setValuesPointer(int const,SbColor const *)\n"
    "    SoMFColor::setValuesPointer(int const,SbColor *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_initClass", 0, 0, 0)) SWIG_fail;
  SoMFColor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[3] = (float (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float (*temp4)[3] ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValues" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        temp4 = (float (*)[3]) malloc(len*3*sizeof(float));
        convert_SoMFVec3f_array(swig_obj[3], len, temp4);
      } else {
        temp4 = NULL; 
      }
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(float const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setHSVValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[3] = (float (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float (*temp4)[3] ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor_setHSVValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setHSVValues" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setHSVValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_setHSVValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        temp4 = (float (*)[3]) malloc(len*3*sizeof(float));
        convert_SoMFVec3f_array(swig_obj[3], len, temp4);
      } else {
        temp4 = NULL; 
      }
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setHSVValues(arg2,arg3,(float const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setValue((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColor_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setHSVValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColor_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setHSVValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setHSVValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  {
    convert_SbVec3f_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_setHSVValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFColor_setHSVValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFColor_setHSVValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::setHSVValue(float,float,float)\n"
    "    SoMFColor::setHSVValue(float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1Value" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColor_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor_set1Value" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->set1Value(arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1Value" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColor_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColor_set1Value" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1Value__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[3] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1Value" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec3f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor_set1Value__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = PySequence_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFColor_set1Value__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFColor_set1Value__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::set1Value(int const,SbColor const &)\n"
    "    SoMFColor::set1Value(int,SbVec3f const &)\n"
    "    SoMFColor::set1Value(int,float,float,float)\n"
    "    SoMFColor::set1Value(int,float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1HSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1HSVValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1HSVValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_set1HSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColor_set1HSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColor_set1HSVValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->set1HSVValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1HSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[3] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_set1HSVValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor_set1HSVValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec3f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1HSVValue(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_set1HSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_set1HSVValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = PySequence_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFColor_set1HSVValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFColor_set1HSVValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_set1HSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::set1HSVValue(int,float,float,float)\n"
    "    SoMFColor::set1HSVValue(int,float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColor___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor___getitem__" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor *) &SoMFColor___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  SbColor *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor___setitem__" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColor___setitem__" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColor___setitem__" "', argument " "3"" of type '" "SbColor const &""'"); 
  }
  arg3 = reinterpret_cast< SbColor * >(argp3);
  SoMFColor___setitem____SWIG_0(arg1,arg2,(SbColor const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float temp3[3] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor___setitem__" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColor___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec3f_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  SoMFColor___setitem____SWIG_1(arg1,arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColor___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = PySequence_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFColor___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::__setitem__(int,SbColor const &)\n"
    "    SoMFColor::__setitem__(int,float const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_setValue" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColor_setValue" "', argument " "2"" of type '" "SoMFColor const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  SoMFColor_setValue__SWIG_4(arg1,(SoMFColor const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColor_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColor_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFColor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColor_setValue__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFColor_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFColor_setValue__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::setValue(SbColor const &)\n"
    "    SoMFColor::setValue(SbVec3f const &)\n"
    "    SoMFColor::setValue(float,float,float)\n"
    "    SoMFColor::setValue(float const [3])\n"
    "    SoMFColor::setValue(SoMFColor const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColor_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbColor *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_getValues" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColor_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbColor *)SoMFColor___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, 
          SWIG_NewPointerObj((void*)(result+i), SWIGTYPE_p_SbColor, 0));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColor *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbColor *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColor_getValues" "', argument " "1"" of type '" "SoMFColor *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColor * >(argp1);
  result = (SbColor *)SoMFColor___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, 
          SWIG_NewPointerObj((void*)(result+i), SWIGTYPE_p_SbColor, 0));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColor_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColor_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFColor_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFColor_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColor_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColor::__getValuesHelper__(int &,int)\n"
    "    SoMFColor::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFColorRGBA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFColorRGBA", 0, 0, 0)) SWIG_fail;
  result = (SoMFColorRGBA *)new SoMFColorRGBA();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColorRGBA, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFColorRGBA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFColorRGBA" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFColorRGBA::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFColorRGBA::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_getTypeId" "', argument " "1"" of type '" "SoMFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  result = ((SoMFColorRGBA const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_copyFrom" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_isSame" "', argument " "1"" of type '" "SoMFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFColorRGBA const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_getValues" "', argument " "1"" of type '" "SoMFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbColor4f *)((SoMFColorRGBA const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_find" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_find" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_find" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbColor4f const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_find" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_find" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_find" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  result = (int)(arg1)->find((SbColor4f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColorRGBA_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFColorRGBA_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::find(SbColor4f const &,SbBool)\n"
    "    SoMFColorRGBA::find(SbColor4f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbColor4f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValues" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFColorRGBA_setValues" "', argument " "4"" of type '" "SbColor4f const *""'"); 
  }
  arg4 = reinterpret_cast< SbColor4f * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbColor4f const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  SbColor4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1Value" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "SbColor4f const &""'"); 
  }
  arg3 = reinterpret_cast< SbColor4f * >(argp3);
  (arg1)->set1Value(arg2,(SbColor4f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  (arg1)->setValue((SbColor4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SoMFColorRGBA *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA___eq__" "', argument " "1"" of type '" "SoMFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFColorRGBA,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA___eq__" "', argument " "2"" of type '" "SoMFColorRGBA const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA___eq__" "', argument " "2"" of type '" "SoMFColorRGBA const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFColorRGBA * >(argp2);
  result = (SbBool)((SoMFColorRGBA const *)arg1)->operator ==((SoMFColorRGBA const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SoMFColorRGBA *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA___ne__" "', argument " "1"" of type '" "SoMFColorRGBA const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFColorRGBA,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA___ne__" "', argument " "2"" of type '" "SoMFColorRGBA const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA___ne__" "', argument " "2"" of type '" "SoMFColorRGBA const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFColorRGBA * >(argp2);
  result = (SbBool)((SoMFColorRGBA const *)arg1)->operator !=((SoMFColorRGBA const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_startEditing" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  result = (SbColor4f *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_finishEditing" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(float const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (float *)malloc(len*sizeof(float));
      convert_SoMFFloat_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  SbColor4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "3"" of type '" "SbColor4f const *""'"); 
  }
  arg3 = reinterpret_cast< SbColor4f * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbColor4f const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  SbColor4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbColor4f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_setValuesPointer" "', argument " "3"" of type '" "SbColor4f *""'"); 
  }
  arg3 = reinterpret_cast< SbColor4f * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor4f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbColor4f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::setValuesPointer(int const,float const *)\n"
    "    SoMFColorRGBA::setValuesPointer(int const,float *)\n"
    "    SoMFColorRGBA::setValuesPointer(int const,SbColor4f const *)\n"
    "    SoMFColorRGBA::setValuesPointer(int const,SbColor4f *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_initClass", 0, 0, 0)) SWIG_fail;
  SoMFColorRGBA::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[4] = (float (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValues" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFColorRGBA_setValues" "', argument " "4"" of type '" "float const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< float (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(float const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbColor4f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFColorRGBA_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFColorRGBA_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::setValues(int const,int const,SbColor4f const *)\n"
    "    SoMFColorRGBA::setValues(int,int,float const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setHSVValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  float (*arg4)[4] = (float (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_setHSVValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setHSVValues" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setHSVValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_setHSVValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFColorRGBA_setHSVValues" "', argument " "4"" of type '" "float const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< float (*)[4] >(argp4);
  (arg1)->setHSVValues(arg2,arg3,(float const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setValue((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColorRGBA_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColorRGBA_setValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_setValue" "', argument " "2"" of type '" "float const [4]""'"); 
  } 
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->setValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbColor4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColorRGBA_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColorRGBA_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColorRGBA_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFColorRGBA_setValue__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::setValue(SbColor4f const &)\n"
    "    SoMFColorRGBA::setValue(SbVec4f const &)\n"
    "    SoMFColorRGBA::setValue(float,float,float,float)\n"
    "    SoMFColorRGBA::setValue(float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setHSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setHSVValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setHSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  float *arg2 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFColorRGBA_setHSVValue" "', argument " "2"" of type '" "float const [4]""'"); 
  } 
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->setHSVValue((float const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_setHSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_setHSVValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFColorRGBA_setHSVValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFColorRGBA_setHSVValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_setHSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::setHSVValue(float,float,float,float)\n"
    "    SoMFColorRGBA::setHSVValue(float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  SbVec4f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1Value" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "SbVec4f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4f * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1Value" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColorRGBA_set1Value" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColorRGBA_set1Value" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFColorRGBA_set1Value" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1Value__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1Value" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_set1Value" "', argument " "3"" of type '" "float const [4]""'"); 
  } 
  arg3 = reinterpret_cast< float * >(argp3);
  (arg1)->set1Value(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbColor4f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_set1Value__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_set1Value__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFColorRGBA_set1Value__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::set1Value(int const,SbColor4f const &)\n"
    "    SoMFColorRGBA::set1Value(int,SbVec4f const &)\n"
    "    SoMFColorRGBA::set1Value(int,float,float,float,float)\n"
    "    SoMFColorRGBA::set1Value(int,float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1HSVValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->set1HSVValue(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1HSVValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFColorRGBA *arg1 = 0 ;
  int arg2 ;
  float *arg3 = (float *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFColorRGBA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "1"" of type '" "SoMFColorRGBA *""'"); 
  }
  arg1 = reinterpret_cast< SoMFColorRGBA * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFColorRGBA_set1HSVValue" "', argument " "3"" of type '" "float const [4]""'"); 
  } 
  arg3 = reinterpret_cast< float * >(argp3);
  (arg1)->set1HSVValue(arg2,(float const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFColorRGBA_set1HSVValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFColorRGBA_set1HSVValue", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFColorRGBA_set1HSVValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFColorRGBA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFColorRGBA_set1HSVValue__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFColorRGBA_set1HSVValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFColorRGBA::set1HSVValue(int,float,float,float,float)\n"
    "    SoMFColorRGBA::set1HSVValue(int,float const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFColorRGBA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFColorRGBA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFColorRGBA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFDouble", 0, 0, 0)) SWIG_fail;
  result = (SoMFDouble *)new SoMFDouble();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFDouble, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFDouble" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFDouble::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFDouble::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_getTypeId" "', argument " "1"" of type '" "SoMFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  result = ((SoMFDouble const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_copyFrom" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFDouble_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFDouble_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_isSame" "', argument " "1"" of type '" "SoMFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFDouble_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFDouble_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFDouble const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_getValues" "', argument " "1"" of type '" "SoMFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double *)((SoMFDouble const *)arg1)->getValues(arg2);
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  double arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_find" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_find" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFDouble_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_find" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_find" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFDouble_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFDouble, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFDouble_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFDouble, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFDouble_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFDouble_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFDouble::find(double,SbBool)\n"
    "    SoMFDouble::find(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_setValues" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFDouble_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFDouble_setValues" "', argument " "4"" of type '" "double const *""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  (arg1)->setValues(arg2,arg3,(double const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_set1Value" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFDouble_set1Value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_setValue" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  SoMFDouble *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble___eq__" "', argument " "1"" of type '" "SoMFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFDouble,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFDouble___eq__" "', argument " "2"" of type '" "SoMFDouble const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFDouble___eq__" "', argument " "2"" of type '" "SoMFDouble const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFDouble * >(argp2);
  result = (SbBool)((SoMFDouble const *)arg1)->operator ==((SoMFDouble const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFDouble___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  SoMFDouble *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble___ne__" "', argument " "1"" of type '" "SoMFDouble const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFDouble,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFDouble___ne__" "', argument " "2"" of type '" "SoMFDouble const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFDouble___ne__" "', argument " "2"" of type '" "SoMFDouble const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFDouble * >(argp2);
  result = (SbBool)((SoMFDouble const *)arg1)->operator !=((SoMFDouble const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_startEditing" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  result = (double *)(arg1)->startEditing();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_finishEditing" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_setValuesPointer" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFDouble_setValuesPointer" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFDouble *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFDouble_setValuesPointer" "', argument " "1"" of type '" "SoMFDouble *""'"); 
  }
  arg1 = reinterpret_cast< SoMFDouble * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFDouble_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFDouble_setValuesPointer" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFDouble_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFDouble, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFDouble_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFDouble, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFDouble_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFDouble_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFDouble::setValuesPointer(int const,double const *)\n"
    "    SoMFDouble::setValuesPointer(int const,double *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFDouble_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFDouble_initClass", 0, 0, 0)) SWIG_fail;
  SoMFDouble::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMFDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFDouble, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFDouble_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFEngine", 0, 0, 0)) SWIG_fail;
  result = (SoMFEngine *)new SoMFEngine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEngine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFEngine" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFEngine::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFEngine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_getTypeId" "', argument " "1"" of type '" "SoMFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  result = ((SoMFEngine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_copyFrom" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEngine_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_isSame" "', argument " "1"" of type '" "SoMFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEngine_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFEngine const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_find" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_find" "', argument " "2"" of type '" "SoEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEngine_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_find" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_find" "', argument " "2"" of type '" "SoEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEngine_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFEngine_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFEngine_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEngine_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEngine::find(SoEngine *,SbBool)\n"
    "    SoMFEngine::find(SoEngine *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SoEngine **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_setValues" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEngine_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = (SoEngine **)malloc(len * sizeof(SoEngine *));
        for (int i = 0; i < len; i++ ) {
          SWIG_ConvertPtr(PyList_GetItem(swig_obj[3],i), (void **) arg4 + i, SWIGTYPE_p_SoEngine,1);
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      return NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(SoEngine const **)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  SoEngine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_set1Value" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFEngine_set1Value" "', argument " "3"" of type '" "SoEngine *""'"); 
  }
  arg3 = reinterpret_cast< SoEngine * >(argp3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_setValue" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_setValue" "', argument " "2"" of type '" "SoEngine *""'"); 
  }
  arg2 = reinterpret_cast< SoEngine * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoMFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine___eq__" "', argument " "1"" of type '" "SoMFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFEngine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine___eq__" "', argument " "2"" of type '" "SoMFEngine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEngine___eq__" "', argument " "2"" of type '" "SoMFEngine const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFEngine * >(argp2);
  result = (SbBool)((SoMFEngine const *)arg1)->operator ==((SoMFEngine const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFEngine___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoMFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine___ne__" "', argument " "1"" of type '" "SoMFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFEngine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine___ne__" "', argument " "2"" of type '" "SoMFEngine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFEngine___ne__" "', argument " "2"" of type '" "SoMFEngine const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFEngine * >(argp2);
  result = (SbBool)((SoMFEngine const *)arg1)->operator !=((SoMFEngine const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngine **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_startEditing" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  result = (SoEngine **)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoEngine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_finishEditing" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_initClass", 0, 0, 0)) SWIG_fail;
  SoMFEngine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_fixCopy" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_referencesCopy" "', argument " "1"" of type '" "SoMFEngine const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  result = (SbBool)((SoMFEngine const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_deleteValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_deleteValues" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEngine_deleteValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->deleteValues(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_deleteValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_deleteValues" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deleteValues(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_deleteValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEngine_deleteValues", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFEngine_deleteValues__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFEngine_deleteValues__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEngine_deleteValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEngine::deleteValues(int,int)\n"
    "    SoMFEngine::deleteValues(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_insertSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine_insertSpace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_insertSpace" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine_insertSpace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEngine_insertSpace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertSpace(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoEngine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine___getitem__" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoEngine *)SoMFEngine___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int arg2 ;
  SoEngine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFEngine___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine___setitem__" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFEngine___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoEngine, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFEngine___setitem__" "', argument " "3"" of type '" "SoEngine *""'"); 
  }
  arg3 = reinterpret_cast< SoEngine * >(argp3);
  SoMFEngine___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  SoMFEngine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_setValue" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFEngine_setValue" "', argument " "2"" of type '" "SoMFEngine const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEngine * >(argp2);
  SoMFEngine_setValue__SWIG_1(arg1,(SoMFEngine const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEngine_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFEngine_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFEngine, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFEngine_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEngine_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEngine::setValue(SoEngine *)\n"
    "    SoMFEngine::setValue(SoMFEngine const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SoEngine **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_getValues" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFEngine_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoEngine **)SoMFEngine___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoEngine, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_base(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFEngine *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SoEngine **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFEngine_getValues" "', argument " "1"" of type '" "SoMFEngine *""'"); 
  }
  arg1 = reinterpret_cast< SoMFEngine * >(argp1);
  result = (SoEngine **)SoMFEngine___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoEngine, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_base(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFEngine_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFEngine_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFEngine_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFEngine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFEngine_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFEngine_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFEngine::__getValuesHelper__(int &,int)\n"
    "    SoMFEngine::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFEngine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFBitMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBitMask *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFBitMask", 0, 0, 0)) SWIG_fail;
  result = (SoMFBitMask *)new SoMFBitMask();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFBitMask, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFBitMask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBitMask *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBitMask, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFBitMask" "', argument " "1"" of type '" "SoMFBitMask *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBitMask * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBitMask_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFBitMask::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBitMask_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFBitMask::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBitMask *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBitMask_getTypeId" "', argument " "1"" of type '" "SoMFBitMask const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBitMask * >(argp1);
  result = ((SoMFBitMask const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBitMask *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBitMask_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBitMask_copyFrom" "', argument " "1"" of type '" "SoMFBitMask *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBitMask * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBitMask_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBitMask_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFBitMask *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBitMask_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFBitMask_isSame" "', argument " "1"" of type '" "SoMFBitMask const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFBitMask * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFBitMask_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFBitMask_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFBitMask const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFBitMask_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFBitMask_initClass", 0, 0, 0)) SWIG_fail;
  SoMFBitMask::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMFBitMask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFBitMask, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFBitMask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFInt32", 0, 0, 0)) SWIG_fail;
  result = (SoMFInt32 *)new SoMFInt32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFInt32" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFInt32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFInt32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_getTypeId" "', argument " "1"" of type '" "SoMFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  result = ((SoMFInt32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_copyFrom" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_isSame" "', argument " "1"" of type '" "SoMFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFInt32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int32_t arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_find" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_find" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFInt32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_find" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_find" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFInt32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFInt32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFInt32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFInt32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFInt32::find(int32_t,SbBool)\n"
    "    SoMFInt32::find(int32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int32_t *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_setValues" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFInt32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[3], len, temp4);
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(int32_t const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_set1Value" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFInt32_set1Value" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_setValue" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32___eq__" "', argument " "1"" of type '" "SoMFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFInt32___eq__" "', argument " "2"" of type '" "SoMFInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFInt32___eq__" "', argument " "2"" of type '" "SoMFInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  result = (SbBool)((SoMFInt32 const *)arg1)->operator ==((SoMFInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFInt32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32___ne__" "', argument " "1"" of type '" "SoMFInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFInt32___ne__" "', argument " "2"" of type '" "SoMFInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFInt32___ne__" "', argument " "2"" of type '" "SoMFInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  result = (SbBool)((SoMFInt32 const *)arg1)->operator !=((SoMFInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_startEditing" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  result = (int32_t *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_finishEditing" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_setValuesPointer" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(int32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_setValuesPointer" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFInt32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFInt32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFInt32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFInt32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFInt32::setValuesPointer(int const,int32_t const *)\n"
    "    SoMFInt32::setValuesPointer(int const,int32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFInt32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32___getitem__" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int32_t)SoMFInt32___getitem__(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFInt32___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32___setitem__" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFInt32___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFInt32___setitem__" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  SoMFInt32___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_setValue" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFInt32_setValue" "', argument " "2"" of type '" "SoMFInt32 const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  SoMFInt32_setValue__SWIG_1(arg1,(SoMFInt32 const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFInt32_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFInt32, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFInt32_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFInt32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFInt32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFInt32::setValue(int32_t)\n"
    "    SoMFInt32::setValue(SoMFInt32 const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int32_t *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_getValues" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFInt32_getValues" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  result = (int32_t *)SoMFInt32___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFInt32 *arg1 = 0 ;
  int32_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t temp2 ;
  int32_t *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFInt32_getValues" "', argument " "1"" of type '" "SoMFInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFInt32 * >(argp1);
  result = (int32_t *)SoMFInt32___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFInt32_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFInt32_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFInt32_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFInt32_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFInt32_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFInt32::__getValuesHelper__(int32_t &,int32_t)\n"
    "    SoMFInt32::__getValuesHelper__(int32_t &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFInt32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFInt32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFInt32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFNode", 0, 0, 0)) SWIG_fail;
  result = (SoMFNode *)new SoMFNode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFNode::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFNode::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_getTypeId" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  result = ((SoMFNode const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_copyFrom" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFNode_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_isSame" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFNode_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFNode const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_find" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_find" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_find" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_find" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFNode_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFNode_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::find(SoNode *,SbBool)\n"
    "    SoMFNode::find(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFNode_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SoNode **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_setValues" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if( len > 0 ) {
        arg4 = (SoNode **)malloc(len * sizeof(SoNode *));
        for(int i = 0; i < len; i++ )
        SWIG_ConvertPtr(PyList_GetItem(swig_obj[3],i), (void **) arg4 + i, SWIGTYPE_p_SoNode,1);
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      return NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(SoNode const **)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_set1Value" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFNode_set1Value" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_setValue" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_setValue" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode___eq__" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode___eq__" "', argument " "2"" of type '" "SoMFNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFNode___eq__" "', argument " "2"" of type '" "SoMFNode const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  result = (SbBool)((SoMFNode const *)arg1)->operator ==((SoMFNode const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFNode___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode___ne__" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode___ne__" "', argument " "2"" of type '" "SoMFNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFNode___ne__" "', argument " "2"" of type '" "SoMFNode const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  result = (SbBool)((SoMFNode const *)arg1)->operator !=((SoMFNode const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFNode_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_startEditing" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  result = (SoNode **)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_finishEditing" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_initClass", 0, 0, 0)) SWIG_fail;
  SoMFNode::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_fixCopy" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_referencesCopy" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  result = (SbBool)((SoMFNode const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_addNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_addNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_addNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_addNode" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_insertNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_insertNode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_insertNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_insertNode" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_insertNode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertNode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_getNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_getNode" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_getNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoMFNode const *)arg1)->getNode(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_findNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_findNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_findNode" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_findNode" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoMFNode const *)arg1)->findNode((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getNumNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_getNumNodes" "', argument " "1"" of type '" "SoMFNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  result = (int)((SoMFNode const *)arg1)->getNumNodes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_removeNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_removeNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_removeNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_removeNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_removeNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_removeNode" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_removeNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_removeNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFNode_removeNode__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFNode_removeNode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_removeNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::removeNode(int)\n"
    "    SoMFNode::removeNode(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFNode_removeAllNodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_removeAllNodes" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  (arg1)->removeAllNodes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_replaceNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_replaceNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_replaceNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFNode_replaceNode" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceNode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_replaceNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_replaceNode" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_replaceNode" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFNode_replaceNode" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceNode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_replaceNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_replaceNode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFNode_replaceNode__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFNode_replaceNode__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_replaceNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::replaceNode(int,SoNode *)\n"
    "    SoMFNode::replaceNode(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFNode_deleteValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_deleteValues" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_deleteValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->deleteValues(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_deleteValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_deleteValues" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deleteValues(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_deleteValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_deleteValues", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFNode_deleteValues__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFNode_deleteValues__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_deleteValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::deleteValues(int,int)\n"
    "    SoMFNode::deleteValues(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFNode_insertSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode_insertSpace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_insertSpace" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode_insertSpace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_insertSpace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertSpace(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode___getitem__" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)SoMFNode___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFNode___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode___setitem__" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFNode___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFNode___setitem__" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  SoMFNode___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_setValue" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFNode_setValue" "', argument " "2"" of type '" "SoMFNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  SoMFNode_setValue__SWIG_1(arg1,(SoMFNode const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFNode_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFNode_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::setValue(SoNode *)\n"
    "    SoMFNode::setValue(SoMFNode const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SoNode **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_getValues" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFNode_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoNode **)SoMFNode___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoNode, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_base(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFNode *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SoNode **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFNode_getValues" "', argument " "1"" of type '" "SoMFNode *""'"); 
  }
  arg1 = reinterpret_cast< SoMFNode * >(argp1);
  result = (SoNode **)SoMFNode___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoNode, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_base(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFNode_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFNode_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFNode_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFNode_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFNode_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFNode::__getValuesHelper__(int &,int)\n"
    "    SoMFNode::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFPath", 0, 0, 0)) SWIG_fail;
  result = (SoMFPath *)new SoMFPath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFPath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFPath" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFPath::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFPath::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_getTypeId" "', argument " "1"" of type '" "SoMFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  result = ((SoMFPath const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_copyFrom" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPath_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_isSame" "', argument " "1"" of type '" "SoMFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPath_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFPath const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_find" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_find" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPath_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_find" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_find" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPath_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPath_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFPath_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPath_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPath::find(SoPath *,SbBool)\n"
    "    SoMFPath::find(SoPath *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFPath_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SoPath **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_setValues" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPath_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = (SoPath **)malloc(len * sizeof(SoPath *));
        for (int i = 0; i < len; i++ ) {
          SWIG_ConvertPtr(PyList_GetItem(swig_obj[3],i), (void **) arg4 + i, SWIGTYPE_p_SoPath,1);
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      return NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(SoPath const **)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  SoPath *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_set1Value" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFPath_set1Value" "', argument " "3"" of type '" "SoPath *""'"); 
  }
  arg3 = reinterpret_cast< SoPath * >(argp3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_setValue" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_setValue" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoMFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath___eq__" "', argument " "1"" of type '" "SoMFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath___eq__" "', argument " "2"" of type '" "SoMFPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPath___eq__" "', argument " "2"" of type '" "SoMFPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFPath * >(argp2);
  result = (SbBool)((SoMFPath const *)arg1)->operator ==((SoMFPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFPath___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoMFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath___ne__" "', argument " "1"" of type '" "SoMFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFPath,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath___ne__" "', argument " "2"" of type '" "SoMFPath const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPath___ne__" "', argument " "2"" of type '" "SoMFPath const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFPath * >(argp2);
  result = (SbBool)((SoMFPath const *)arg1)->operator !=((SoMFPath const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFPath_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_startEditing" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  result = (SoPath **)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoPath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_finishEditing" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_initClass", 0, 0, 0)) SWIG_fail;
  SoMFPath::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_notify" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_fixCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_fixCopy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_fixCopy" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_fixCopy" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->fixCopy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_referencesCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_referencesCopy" "', argument " "1"" of type '" "SoMFPath const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  result = (SbBool)((SoMFPath const *)arg1)->referencesCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_deleteValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_deleteValues" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPath_deleteValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->deleteValues(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_deleteValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_deleteValues" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_deleteValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deleteValues(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_deleteValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPath_deleteValues", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFPath_deleteValues__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFPath_deleteValues__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPath_deleteValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPath::deleteValues(int,int)\n"
    "    SoMFPath::deleteValues(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFPath_insertSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath_insertSpace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_insertSpace" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath_insertSpace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPath_insertSpace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertSpace(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath___getitem__" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPath *)SoMFPath___getitem__(arg1,arg2);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int arg2 ;
  SoPath *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPath___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath___setitem__" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPath___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFPath___setitem__" "', argument " "3"" of type '" "SoPath *""'"); 
  }
  arg3 = reinterpret_cast< SoPath * >(argp3);
  SoMFPath___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  SoMFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_setValue" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPath_setValue" "', argument " "2"" of type '" "SoMFPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFPath * >(argp2);
  SoMFPath_setValue__SWIG_1(arg1,(SoMFPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPath_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPath_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPath_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPath_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPath::setValue(SoPath *)\n"
    "    SoMFPath::setValue(SoMFPath const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFPath_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SoPath **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_getValues" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPath_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SoPath **)SoMFPath___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoPath, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_path(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPath *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SoPath **result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPath_getValues" "', argument " "1"" of type '" "SoMFPath *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPath * >(argp1);
  result = (SoPath **)SoMFPath___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SoPath, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, autocast_path(result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPath_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPath_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFPath_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFPath_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPath_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPath::__getValuesHelper__(int &,int)\n"
    "    SoMFPath::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFPath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFPlane", 0, 0, 0)) SWIG_fail;
  result = (SoMFPlane *)new SoMFPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFPlane" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFPlane::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFPlane::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_getTypeId" "', argument " "1"" of type '" "SoMFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  result = ((SoMFPlane const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_copyFrom" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_isSame" "', argument " "1"" of type '" "SoMFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFPlane const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_find" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_find" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_find" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPlane_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbPlane const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_find" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_find" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_find" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  result = (int)(arg1)->find((SbPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPlane_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPlane_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFPlane_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPlane_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPlane::find(SbPlane const &,SbBool)\n"
    "    SoMFPlane::find(SbPlane const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbPlane *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_setValues" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPlane_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPlane_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbPlane[len];
        for (int i = 0; i < len; i++) {
          SbPlane * plane = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &plane, SWIGTYPE_p_SbPlane, 1);
          arg4[i] = *plane;
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbPlane const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int arg2 ;
  SbPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_set1Value" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPlane_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFPlane_set1Value" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_set1Value" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbPlane * >(argp3);
  (arg1)->set1Value(arg2,(SbPlane const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_setValue" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_setValue" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane_setValue" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  (arg1)->setValue((SbPlane const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SoMFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane___eq__" "', argument " "1"" of type '" "SoMFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane___eq__" "', argument " "2"" of type '" "SoMFPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane___eq__" "', argument " "2"" of type '" "SoMFPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFPlane * >(argp2);
  result = (SbBool)((SoMFPlane const *)arg1)->operator ==((SoMFPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFPlane___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SoMFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane___ne__" "', argument " "1"" of type '" "SoMFPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane___ne__" "', argument " "2"" of type '" "SoMFPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane___ne__" "', argument " "2"" of type '" "SoMFPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFPlane * >(argp2);
  result = (SbBool)((SoMFPlane const *)arg1)->operator !=((SoMFPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbPlane *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_startEditing" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  result = (SbPlane *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_finishEditing" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane_initClass", 0, 0, 0)) SWIG_fail;
  SoMFPlane::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbPlane *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane___getitem__" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPlane___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbPlane *) &SoMFPlane___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int arg2 ;
  SbPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFPlane___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane___setitem__" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFPlane___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFPlane___setitem__" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFPlane___setitem__" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbPlane * >(argp3);
  SoMFPlane___setitem__(arg1,arg2,(SbPlane const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbPlane *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_getValues" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFPlane_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbPlane *)SoMFPlane___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbPlane * plane = new SbPlane( result[i] );
        PyObject * obj = SWIG_NewPointerObj(plane, SWIGTYPE_p_SbPlane, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbPlane *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_getValues" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  result = (SbPlane *)SoMFPlane___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbPlane * plane = new SbPlane( result[i] );
        PyObject * obj = SWIG_NewPointerObj(plane, SWIGTYPE_p_SbPlane, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPlane_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFPlane_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFPlane_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPlane_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPlane::__getValuesHelper__(int &,int)\n"
    "    SoMFPlane::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFPlane *arg1 = 0 ;
  SoMFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFPlane_setValue" "', argument " "1"" of type '" "SoMFPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoMFPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFPlane_setValue" "', argument " "2"" of type '" "SoMFPlane const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFPlane * >(argp2);
  SoMFPlane_setValue__SWIG_1(arg1,(SoMFPlane const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFPlane_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFPlane_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPlane_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFPlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFPlane_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFPlane_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFPlane::setValue(SbPlane const &)\n"
    "    SoMFPlane::setValue(SoMFPlane const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFPlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFPlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFPlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFShort", 0, 0, 0)) SWIG_fail;
  result = (SoMFShort *)new SoMFShort();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFShort, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFShort" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFShort::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFShort::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_getTypeId" "', argument " "1"" of type '" "SoMFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  result = ((SoMFShort const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_copyFrom" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_isSame" "', argument " "1"" of type '" "SoMFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFShort const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  short arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_find" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_find" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFShort_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_find" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_find" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFShort_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFShort_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFShort_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFShort_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFShort::find(short,SbBool)\n"
    "    SoMFShort::find(short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  short *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_setValues" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFShort_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(short const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_set1Value" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFShort_set1Value" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_setValue" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  SoMFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort___eq__" "', argument " "1"" of type '" "SoMFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFShort___eq__" "', argument " "2"" of type '" "SoMFShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFShort___eq__" "', argument " "2"" of type '" "SoMFShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFShort * >(argp2);
  result = (SbBool)((SoMFShort const *)arg1)->operator ==((SoMFShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFShort___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  SoMFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort___ne__" "', argument " "1"" of type '" "SoMFShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFShort___ne__" "', argument " "2"" of type '" "SoMFShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFShort___ne__" "', argument " "2"" of type '" "SoMFShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFShort * >(argp2);
  result = (SbBool)((SoMFShort const *)arg1)->operator !=((SoMFShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFShort_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_startEditing" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  result = (short *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_finishEditing" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_setValuesPointer" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_setValuesPointer" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFShort_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFShort_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFShort_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFShort_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFShort::setValuesPointer(int const,short const *)\n"
    "    SoMFShort::setValuesPointer(int const,short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFShort_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort_initClass", 0, 0, 0)) SWIG_fail;
  SoMFShort::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort___getitem__" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (short)SoMFShort___getitem__(arg1,arg2);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFShort___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort___setitem__" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFShort___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFShort___setitem__" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  SoMFShort___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  SoMFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_setValue" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFShort_setValue" "', argument " "2"" of type '" "SoMFShort const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFShort * >(argp2);
  SoMFShort_setValue__SWIG_1(arg1,(SoMFShort const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFShort_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFShort, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFShort_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFShort_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFShort_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFShort::setValue(short)\n"
    "    SoMFShort::setValue(SoMFShort const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFShort_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  short *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_getValues" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFShort_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (short *)SoMFShort___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFShort *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  short *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFShort_getValues" "', argument " "1"" of type '" "SoMFShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFShort * >(argp1);
  result = (short *)SoMFShort___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFShort_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFShort_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFShort_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFShort_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFShort_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFShort::__getValuesHelper__(int &,int)\n"
    "    SoMFShort::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFShort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFShort, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFShort_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFTime", 0, 0, 0)) SWIG_fail;
  result = (SoMFTime *)new SoMFTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFTime" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFTime::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFTime::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_getTypeId" "', argument " "1"" of type '" "SoMFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  result = ((SoMFTime const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_copyFrom" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFTime_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFTime_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_isSame" "', argument " "1"" of type '" "SoMFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFTime_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFTime_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFTime const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_find" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFTime_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbTime const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_find" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (int)(arg1)->find((SbTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFTime_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFTime_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFTime_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFTime_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFTime::find(SbTime const &,SbBool)\n"
    "    SoMFTime::find(SbTime const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFTime_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbTime *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_setValues" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFTime_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFTime_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbTime[len];
        for (int i = 0; i < len; i++) {
          SbTime * time = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &time, SWIGTYPE_p_SbTime, 1);
          arg4[i] = *time;
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbTime const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int arg2 ;
  SbTime *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_set1Value" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFTime_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyFloat_Check(swig_obj[2])) {
      arg3 = new SbTime(PyFloat_AsDouble(swig_obj[2]));
    } else {
      SbTime * tmp = NULL;
      arg3 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg3 = *tmp;
    }
  }
  (arg1)->set1Value(arg2,(SbTime const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_setValue" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setValue((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SoMFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime___eq__" "', argument " "1"" of type '" "SoMFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFTime___eq__" "', argument " "2"" of type '" "SoMFTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFTime___eq__" "', argument " "2"" of type '" "SoMFTime const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFTime * >(argp2);
  result = (SbBool)((SoMFTime const *)arg1)->operator ==((SoMFTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFTime___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SoMFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime___ne__" "', argument " "1"" of type '" "SoMFTime const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFTime,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFTime___ne__" "', argument " "2"" of type '" "SoMFTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFTime___ne__" "', argument " "2"" of type '" "SoMFTime const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFTime * >(argp2);
  result = (SbBool)((SoMFTime const *)arg1)->operator !=((SoMFTime const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFTime_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_startEditing" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  result = (SbTime *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_finishEditing" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime_initClass", 0, 0, 0)) SWIG_fail;
  SoMFTime::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime___getitem__" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFTime___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbTime *) &SoMFTime___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int arg2 ;
  SbTime *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFTime___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime___setitem__" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFTime___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (PyFloat_Check(swig_obj[2])) {
      arg3 = new SbTime(PyFloat_AsDouble(swig_obj[2]));
    } else {
      SbTime * tmp = NULL;
      arg3 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg3 = *tmp;
    }
  }
  SoMFTime___setitem__(arg1,arg2,(SbTime const &)*arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbTime *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_getValues" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFTime_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbTime *)SoMFTime___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        SbTime * time = new SbTime( result[i] );
        PyObject * obj = SWIG_NewPointerObj(time, SWIGTYPE_p_SbTime, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbTime *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_getValues" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  result = (SbTime *)SoMFTime___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        SbTime * time = new SbTime( result[i] );
        PyObject * obj = SWIG_NewPointerObj(time, SWIGTYPE_p_SbTime, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFTime_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFTime_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFTime_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFTime_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFTime::__getValuesHelper__(int &,int)\n"
    "    SoMFTime::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFTime_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFTime *arg1 = 0 ;
  SoMFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFTime_setValue" "', argument " "1"" of type '" "SoMFTime *""'"); 
  }
  arg1 = reinterpret_cast< SoMFTime * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFTime_setValue" "', argument " "2"" of type '" "SoMFTime const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFTime * >(argp2);
  SoMFTime_setValue__SWIG_1(arg1,(SoMFTime const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFTime_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFTime_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFTime, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFTime_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        if (!PyFloat_Check(argv[1]) && (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbTime, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoMFTime_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFTime_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFTime::setValue(SbTime const &)\n"
    "    SoMFTime::setValue(SoMFTime const *)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFUInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFUInt32", 0, 0, 0)) SWIG_fail;
  result = (SoMFUInt32 *)new SoMFUInt32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFUInt32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFUInt32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFUInt32" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFUInt32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFUInt32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_getTypeId" "', argument " "1"" of type '" "SoMFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  result = ((SoMFUInt32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_copyFrom" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUInt32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_isSame" "', argument " "1"" of type '" "SoMFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUInt32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFUInt32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  uint32_t arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_find" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_find" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUInt32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_find" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_find" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUInt32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUInt32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFUInt32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUInt32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUInt32::find(uint32_t,SbBool)\n"
    "    SoMFUInt32::find(uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  uint32_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  uint32_t *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_setValues" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUInt32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (uint32_t*)malloc(len*sizeof(uint32_t));
      convert_SoMFUInt32_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(uint32_t const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_set1Value" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUInt32_set1Value" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_setValue" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_setValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  SoMFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32___eq__" "', argument " "1"" of type '" "SoMFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFUInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUInt32___eq__" "', argument " "2"" of type '" "SoMFUInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUInt32___eq__" "', argument " "2"" of type '" "SoMFUInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFUInt32 * >(argp2);
  result = (SbBool)((SoMFUInt32 const *)arg1)->operator ==((SoMFUInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  SoMFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32___ne__" "', argument " "1"" of type '" "SoMFUInt32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFUInt32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUInt32___ne__" "', argument " "2"" of type '" "SoMFUInt32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUInt32___ne__" "', argument " "2"" of type '" "SoMFUInt32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFUInt32 * >(argp2);
  result = (SbBool)((SoMFUInt32 const *)arg1)->operator !=((SoMFUInt32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_startEditing" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  result = (uint32_t *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_finishEditing" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  uint32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_setValuesPointer" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (uint32_t*)malloc(len*sizeof(uint32_t));
      convert_SoMFUInt32_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(uint32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  uint32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_setValuesPointer" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (uint32_t*)malloc(len*sizeof(uint32_t));
      convert_SoMFUInt32_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUInt32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFUInt32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFUInt32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUInt32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUInt32::setValuesPointer(int const,uint32_t const *)\n"
    "    SoMFUInt32::setValuesPointer(int const,uint32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFUInt32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32___getitem__" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (uint32_t)SoMFUInt32___getitem__(arg1,arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int arg2 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUInt32___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32___setitem__" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUInt32___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUInt32___setitem__" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  SoMFUInt32___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  SoMFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_setValue" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUInt32_setValue" "', argument " "2"" of type '" "SoMFUInt32 const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFUInt32 * >(argp2);
  SoMFUInt32_setValue__SWIG_1(arg1,(SoMFUInt32 const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUInt32_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFUInt32_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUInt32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUInt32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUInt32::setValue(uint32_t)\n"
    "    SoMFUInt32::setValue(SoMFUInt32 const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  uint32_t *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_getValues" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUInt32_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (uint32_t *)SoMFUInt32___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUInt32 *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  uint32_t *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUInt32_getValues" "', argument " "1"" of type '" "SoMFUInt32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUInt32 * >(argp1);
  result = (uint32_t *)SoMFUInt32___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUInt32_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUInt32_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFUInt32_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUInt32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUInt32_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUInt32_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUInt32::__getValuesHelper__(int &,int)\n"
    "    SoMFUInt32::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFUInt32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFUInt32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFUInt32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFUShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFUShort", 0, 0, 0)) SWIG_fail;
  result = (SoMFUShort *)new SoMFUShort();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFUShort, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFUShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFUShort" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFUShort::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFUShort::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_getTypeId" "', argument " "1"" of type '" "SoMFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  result = ((SoMFUShort const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_copyFrom" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUShort_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_isSame" "', argument " "1"" of type '" "SoMFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUShort_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFUShort const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  unsigned short arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_find" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_find" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUShort_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_find" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_find" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (int)(arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUShort_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUShort_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFUShort_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUShort_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUShort::find(unsigned short,SbBool)\n"
    "    SoMFUShort::find(unsigned short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  unsigned short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned short *temp4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_setValues", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_setValues" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUShort_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (unsigned short*)malloc(len*sizeof(unsigned short));
      convert_SoMFUShort_array(swig_obj[3], len, temp4);
      
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(unsigned short const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_set1Value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_set1Value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_set1Value" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUShort_set1Value" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->set1Value(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_setValue" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_setValue" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  SoMFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort___eq__" "', argument " "1"" of type '" "SoMFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFUShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUShort___eq__" "', argument " "2"" of type '" "SoMFUShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUShort___eq__" "', argument " "2"" of type '" "SoMFUShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFUShort * >(argp2);
  result = (SbBool)((SoMFUShort const *)arg1)->operator ==((SoMFUShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFUShort___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  SoMFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort___ne__" "', argument " "1"" of type '" "SoMFUShort const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFUShort,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUShort___ne__" "', argument " "2"" of type '" "SoMFUShort const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFUShort___ne__" "', argument " "2"" of type '" "SoMFUShort const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFUShort * >(argp2);
  result = (SbBool)((SoMFUShort const *)arg1)->operator !=((SoMFUShort const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_startEditing" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  result = (unsigned short *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_finishEditing" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  unsigned short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_setValuesPointer" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (unsigned short*)malloc(len*sizeof(unsigned short));
      convert_SoMFUShort_array(swig_obj[2], len, temp3);
      
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(unsigned short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  unsigned short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_setValuesPointer" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (unsigned short*)malloc(len*sizeof(unsigned short));
      convert_SoMFUShort_array(swig_obj[2], len, temp3);
      
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUShort_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFUShort_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFUShort_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUShort_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUShort::setValuesPointer(int const,unsigned short const *)\n"
    "    SoMFUShort::setValuesPointer(int const,unsigned short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort_initClass", 0, 0, 0)) SWIG_fail;
  SoMFUShort::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort___getitem__" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (short)SoMFUShort___getitem__(arg1,arg2);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFUShort___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort___setitem__" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFUShort___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUShort___setitem__" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  SoMFUShort___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  SoMFUShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_setValue" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFUShort_setValue" "', argument " "2"" of type '" "SoMFUShort const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFUShort * >(argp2);
  SoMFUShort_setValue__SWIG_1(arg1,(SoMFUShort const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUShort_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFUShort, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFUShort_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUShort_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUShort_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUShort::setValue(unsigned short)\n"
    "    SoMFUShort::setValue(SoMFUShort const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned short *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_getValues" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFUShort_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (unsigned short *)SoMFUShort___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFUShort *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  unsigned short *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFUShort, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFUShort_getValues" "', argument " "1"" of type '" "SoMFUShort *""'"); 
  }
  arg1 = reinterpret_cast< SoMFUShort * >(argp1);
  result = (unsigned short *)SoMFUShort___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++){
        PyList_SetItem(resultobj, i, PyInt_FromLong((long)result[i]));
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFUShort_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFUShort_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFUShort_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFUShort, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFUShort_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFUShort_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFUShort::__getValuesHelper__(int &,int)\n"
    "    SoMFUShort::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFUShort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFUShort, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFUShort_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec2b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec2b", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec2b *)new SoMFVec2b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec2b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec2b" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec2b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec2b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_getTypeId" "', argument " "1"" of type '" "SoMFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  result = ((SoMFVec2b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_copyFrom" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_isSame" "', argument " "1"" of type '" "SoMFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec2b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_getValues" "', argument " "1"" of type '" "SoMFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2b *)((SoMFVec2b const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_find" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_find" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_find" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2b_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_find" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_find" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_find" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2b_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2b_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2b_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2b_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2b::find(SbVec2b,SbBool)\n"
    "    SoMFVec2b::find(SbVec2b)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec2b *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValues" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2b_setValues" "', argument " "4"" of type '" "SbVec2b const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2b * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec2b const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  SbVec2b arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_set1Value" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_set1Value" "', argument " "3"" of type '" "SbVec2b""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_set1Value" "', argument " "3"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SbVec2b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValue" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_setValue" "', argument " "2"" of type '" "SbVec2b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b_setValue" "', argument " "2"" of type '" "SbVec2b""'");
    } else {
      SbVec2b * temp = reinterpret_cast< SbVec2b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SoMFVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b___eq__" "', argument " "1"" of type '" "SoMFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b___eq__" "', argument " "2"" of type '" "SoMFVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b___eq__" "', argument " "2"" of type '" "SoMFVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2b * >(argp2);
  result = (SbBool)((SoMFVec2b const *)arg1)->operator ==((SoMFVec2b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  SoMFVec2b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b___ne__" "', argument " "1"" of type '" "SoMFVec2b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b___ne__" "', argument " "2"" of type '" "SoMFVec2b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2b___ne__" "', argument " "2"" of type '" "SoMFVec2b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2b * >(argp2);
  result = (SbBool)((SoMFVec2b const *)arg1)->operator !=((SoMFVec2b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2b *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_startEditing" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  result = (SbVec2b *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_finishEditing" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  SbVec2b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "3"" of type '" "SbVec2b const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2b * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec2b const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  SbVec2b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "3"" of type '" "SbVec2b *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2b * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "3"" of type '" "int8_t const *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,(int8_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_setValuesPointer" "', argument " "3"" of type '" "int8_t *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2b_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2b_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2b::setValuesPointer(int const,SbVec2b const *)\n"
    "    SoMFVec2b::setValuesPointer(int const,SbVec2b *)\n"
    "    SoMFVec2b::setValuesPointer(int const,int8_t const *)\n"
    "    SoMFVec2b::setValuesPointer(int const,int8_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2b_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec2b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int8_t (*arg4)[2] = (int8_t (*)[2])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValues" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_2__signed_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2b_setValues" "', argument " "4"" of type '" "int8_t const [][2]""'"); 
  } 
  arg4 = reinterpret_cast< int8_t (*)[2] >(argp4);
  (arg1)->setValues(arg2,arg3,(int8_t const (*)[2])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2b_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2b, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2b_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_2__signed_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2b_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2b_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2b::setValues(int const,int const,SbVec2b const *)\n"
    "    SoMFVec2b::setValues(int,int,int8_t const [][2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_set1Value" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2b_set1Value" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec2b_set1Value" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  (arg1)->set1Value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_set1Value" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2b_set1Value" "', argument " "3"" of type '" "int8_t const [2]""'"); 
  } 
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->set1Value(arg2,(int8_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2b_set1Value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2b_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec2b_set1Value__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2b_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2b::set1Value(int const,SbVec2b)\n"
    "    SoMFVec2b::set1Value(int,int8_t,int8_t)\n"
    "    SoMFVec2b::set1Value(int,int8_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValue" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2b_setValue" "', argument " "1"" of type '" "SoMFVec2b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2b_setValue" "', argument " "2"" of type '" "int8_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2b_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2b_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2b::setValue(SbVec2b)\n"
    "    SoMFVec2b::setValue(int8_t,int8_t)\n"
    "    SoMFVec2b::setValue(int8_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec2b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec2b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec2b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec2s", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec2s *)new SoMFVec2s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec2s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec2s" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec2s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec2s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_getTypeId" "', argument " "1"" of type '" "SoMFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  result = ((SoMFVec2s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_copyFrom" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_isSame" "', argument " "1"" of type '" "SoMFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec2s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_getValues" "', argument " "1"" of type '" "SoMFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2s *)((SoMFVec2s const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_find" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_find" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_find" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2s_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_find" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_find" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_find" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2s_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2s_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2s_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2s_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2s::find(SbVec2s,SbBool)\n"
    "    SoMFVec2s::find(SbVec2s)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec2s *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValues" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2s_setValues" "', argument " "4"" of type '" "SbVec2s const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2s * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec2s const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  SbVec2s arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_set1Value" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2s_set1Value" "', argument " "3"" of type '" "SbVec2s""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_set1Value" "', argument " "3"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValue" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_setValue" "', argument " "2"" of type '" "SbVec2s""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s_setValue" "', argument " "2"" of type '" "SbVec2s""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SoMFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s___eq__" "', argument " "1"" of type '" "SoMFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s___eq__" "', argument " "2"" of type '" "SoMFVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s___eq__" "', argument " "2"" of type '" "SoMFVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2s * >(argp2);
  result = (SbBool)((SoMFVec2s const *)arg1)->operator ==((SoMFVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  SoMFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s___ne__" "', argument " "1"" of type '" "SoMFVec2s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s___ne__" "', argument " "2"" of type '" "SoMFVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2s___ne__" "', argument " "2"" of type '" "SoMFVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2s * >(argp2);
  result = (SbBool)((SoMFVec2s const *)arg1)->operator !=((SoMFVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_startEditing" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  result = (SbVec2s *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_finishEditing" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  SbVec2s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "3"" of type '" "SbVec2s const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec2s const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  SbVec2s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "3"" of type '" "SbVec2s *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2s_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2s_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2s::setValuesPointer(int const,SbVec2s const *)\n"
    "    SoMFVec2s::setValuesPointer(int const,SbVec2s *)\n"
    "    SoMFVec2s::setValuesPointer(int const,short const *)\n"
    "    SoMFVec2s::setValuesPointer(int const,short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2s_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec2s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  short (*arg4)[2] = (short (*)[2])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValues" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_2__short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2s_setValues" "', argument " "4"" of type '" "short const [][2]""'"); 
  } 
  arg4 = reinterpret_cast< short (*)[2] >(argp4);
  (arg1)->setValues(arg2,arg3,(short const (*)[2])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2s_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2s, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2s_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_2__short, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2s_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2s_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2s::setValues(int const,int const,SbVec2s const *)\n"
    "    SoMFVec2s::setValues(int,int,short const [][2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_set1Value" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2s_set1Value" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec2s_set1Value" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  (arg1)->set1Value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_set1Value" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2s_set1Value" "', argument " "3"" of type '" "short const [2]""'"); 
  } 
  arg3 = reinterpret_cast< short * >(argp3);
  (arg1)->set1Value(arg2,(short const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2s_set1Value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2s_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec2s_set1Value__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2s_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2s::set1Value(int const,SbVec2s)\n"
    "    SoMFVec2s::set1Value(int,short,short)\n"
    "    SoMFVec2s::set1Value(int,short const [2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValue" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2s_setValue" "', argument " "1"" of type '" "SoMFVec2s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2s_setValue" "', argument " "2"" of type '" "short const [2]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2s_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2s_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2s::setValue(SbVec2s)\n"
    "    SoMFVec2s::setValue(short,short)\n"
    "    SoMFVec2s::setValue(short const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec2s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec2s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec2s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec2i32", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec2i32 *)new SoMFVec2i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec2i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec2i32" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec2i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec2i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_getTypeId" "', argument " "1"" of type '" "SoMFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  result = ((SoMFVec2i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_copyFrom" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_isSame" "', argument " "1"" of type '" "SoMFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec2i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_getValues" "', argument " "1"" of type '" "SoMFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2i32 *)((SoMFVec2i32 const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_find" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_find" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_find" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2i32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec2i32 const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_find" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_find" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_find" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  result = (int)(arg1)->find((SbVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2i32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2i32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2i32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2i32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2i32::find(SbVec2i32 const &,SbBool)\n"
    "    SoMFVec2i32::find(SbVec2i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec2i32 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValues" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2i32_setValues" "', argument " "4"" of type '" "SbVec2i32 const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2i32 * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec2i32 const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_set1Value" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2i32_set1Value" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_set1Value" "', argument " "3"" of type '" "SbVec2i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  (arg1)->set1Value(arg2,(SbVec2i32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SbVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValue" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32_setValue" "', argument " "2"" of type '" "SbVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2i32 * >(argp2);
  (arg1)->setValue((SbVec2i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SoMFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32___eq__" "', argument " "1"" of type '" "SoMFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32___eq__" "', argument " "2"" of type '" "SoMFVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32___eq__" "', argument " "2"" of type '" "SoMFVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2i32 * >(argp2);
  result = (SbBool)((SoMFVec2i32 const *)arg1)->operator ==((SoMFVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  SoMFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32___ne__" "', argument " "1"" of type '" "SoMFVec2i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32___ne__" "', argument " "2"" of type '" "SoMFVec2i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2i32___ne__" "', argument " "2"" of type '" "SoMFVec2i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2i32 * >(argp2);
  result = (SbBool)((SoMFVec2i32 const *)arg1)->operator !=((SoMFVec2i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_startEditing" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  result = (SbVec2i32 *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_finishEditing" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "3"" of type '" "SbVec2i32 const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec2i32 const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  SbVec2i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "3"" of type '" "SbVec2i32 *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(int32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2i32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2i32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2i32::setValuesPointer(int const,SbVec2i32 const *)\n"
    "    SoMFVec2i32::setValuesPointer(int const,SbVec2i32 *)\n"
    "    SoMFVec2i32::setValuesPointer(int const,int32_t const *)\n"
    "    SoMFVec2i32::setValuesPointer(int const,int32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2i32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec2i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int32_t (*arg4)[2] = (int32_t (*)[2])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValues" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_2__int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2i32_setValues" "', argument " "4"" of type '" "int32_t const [][2]""'"); 
  } 
  arg4 = reinterpret_cast< int32_t (*)[2] >(argp4);
  (arg1)->setValues(arg2,arg3,(int32_t const (*)[2])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2i32_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2i32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2i32_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_2__int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2i32_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2i32_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2i32::setValues(int const,int const,SbVec2i32 const *)\n"
    "    SoMFVec2i32::setValues(int,int,int32_t const [][2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_set1Value" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2i32_set1Value" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec2i32_set1Value" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  (arg1)->set1Value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_set1Value" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2i32_set1Value" "', argument " "3"" of type '" "int32_t const [2]""'"); 
  } 
  arg3 = reinterpret_cast< int32_t * >(argp3);
  (arg1)->set1Value(arg2,(int32_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2i32_set1Value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2i32_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec2i32_set1Value__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2i32_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2i32::set1Value(int const,SbVec2i32 const &)\n"
    "    SoMFVec2i32::set1Value(int,int32_t,int32_t)\n"
    "    SoMFVec2i32::set1Value(int,int32_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValue" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2i32_setValue" "', argument " "1"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2i32_setValue" "', argument " "2"" of type '" "int32_t const [2]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2i32_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2i32_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2i32::setValue(SbVec2i32 const &)\n"
    "    SoMFVec2i32::setValue(int32_t,int32_t)\n"
    "    SoMFVec2i32::setValue(int32_t const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec2i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec2i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec2i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec2d", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec2d *)new SoMFVec2d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec2d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec2d" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec2d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec2d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_getTypeId" "', argument " "1"" of type '" "SoMFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  result = ((SoMFVec2d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_copyFrom" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_isSame" "', argument " "1"" of type '" "SoMFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec2d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_getValues" "', argument " "1"" of type '" "SoMFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec2d *)((SoMFVec2d const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_find" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_find" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_find" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2d_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec2d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_find" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_find" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_find" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  result = (int)(arg1)->find((SbVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2d_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2d_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2d_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2d_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2d::find(SbVec2d const &,SbBool)\n"
    "    SoMFVec2d::find(SbVec2d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec2d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValues" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2d_setValues" "', argument " "4"" of type '" "SbVec2d const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2d * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec2d const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_set1Value" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_set1Value" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_set1Value" "', argument " "3"" of type '" "SbVec2d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  (arg1)->set1Value(arg2,(SbVec2d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SbVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValue" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d_setValue" "', argument " "2"" of type '" "SbVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2d * >(argp2);
  (arg1)->setValue((SbVec2d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SoMFVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d___eq__" "', argument " "1"" of type '" "SoMFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d___eq__" "', argument " "2"" of type '" "SoMFVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d___eq__" "', argument " "2"" of type '" "SoMFVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2d * >(argp2);
  result = (SbBool)((SoMFVec2d const *)arg1)->operator ==((SoMFVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  SoMFVec2d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d___ne__" "', argument " "1"" of type '" "SoMFVec2d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec2d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d___ne__" "', argument " "2"" of type '" "SoMFVec2d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec2d___ne__" "', argument " "2"" of type '" "SoMFVec2d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2d * >(argp2);
  result = (SbBool)((SoMFVec2d const *)arg1)->operator !=((SoMFVec2d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_startEditing" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  result = (SbVec2d *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_finishEditing" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "3"" of type '" "SbVec2d const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec2d const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  SbVec2d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec2d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "3"" of type '" "SbVec2d *""'"); 
  }
  arg3 = reinterpret_cast< SbVec2d * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_setValuesPointer" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2d_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec2d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2d_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2d::setValuesPointer(int const,SbVec2d const *)\n"
    "    SoMFVec2d::setValuesPointer(int const,SbVec2d *)\n"
    "    SoMFVec2d::setValuesPointer(int const,double const *)\n"
    "    SoMFVec2d::setValuesPointer(int const,double *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec2d_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec2d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  double (*arg4)[2] = (double (*)[2])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValues" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_2__double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec2d_setValues" "', argument " "4"" of type '" "double const [][2]""'"); 
  } 
  arg4 = reinterpret_cast< double (*)[2] >(argp4);
  (arg1)->setValues(arg2,arg3,(double const (*)[2])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2d_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2d, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2d_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_2__double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec2d_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2d_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2d::setValues(int const,int const,SbVec2d const *)\n"
    "    SoMFVec2d::setValues(int,int,double const [][2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_set1Value" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2d_set1Value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec2d_set1Value" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set1Value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_set1Value" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec2d_set1Value" "', argument " "3"" of type '" "double const [2]""'"); 
  } 
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->set1Value(arg2,(double const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2d_set1Value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec2d_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec2d_set1Value__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2d_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2d::set1Value(int const,SbVec2d const &)\n"
    "    SoMFVec2d::set1Value(int,double,double)\n"
    "    SoMFVec2d::set1Value(int,double const [2])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValue" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec2d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec2d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setValue(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec2d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec2d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec2d_setValue" "', argument " "1"" of type '" "SoMFVec2d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec2d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec2d_setValue" "', argument " "2"" of type '" "double const [2]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec2d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec2d_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec2d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec2d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec2d_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec2d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec2d::setValue(SbVec2d const &)\n"
    "    SoMFVec2d::setValue(double,double)\n"
    "    SoMFVec2d::setValue(double const [2])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec2d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec2d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec3b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec3b", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec3b *)new SoMFVec3b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec3b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec3b" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec3b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec3b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_getTypeId" "', argument " "1"" of type '" "SoMFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  result = ((SoMFVec3b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_copyFrom" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_isSame" "', argument " "1"" of type '" "SoMFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec3b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_getValues" "', argument " "1"" of type '" "SoMFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3b *)((SoMFVec3b const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_find" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_find" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_find" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3b_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_find" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_find" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_find" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3b_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3b_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec3b_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3b_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3b::find(SbVec3b,SbBool)\n"
    "    SoMFVec3b::find(SbVec3b)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3b *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValues" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3b_setValues" "', argument " "4"" of type '" "SbVec3b const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec3b * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec3b const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  SbVec3b arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_set1Value" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_set1Value" "', argument " "3"" of type '" "SbVec3b""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_set1Value" "', argument " "3"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SbVec3b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValue" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_setValue" "', argument " "2"" of type '" "SbVec3b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b_setValue" "', argument " "2"" of type '" "SbVec3b""'");
    } else {
      SbVec3b * temp = reinterpret_cast< SbVec3b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SoMFVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b___eq__" "', argument " "1"" of type '" "SoMFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b___eq__" "', argument " "2"" of type '" "SoMFVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b___eq__" "', argument " "2"" of type '" "SoMFVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3b * >(argp2);
  result = (SbBool)((SoMFVec3b const *)arg1)->operator ==((SoMFVec3b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  SoMFVec3b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b___ne__" "', argument " "1"" of type '" "SoMFVec3b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b___ne__" "', argument " "2"" of type '" "SoMFVec3b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3b___ne__" "', argument " "2"" of type '" "SoMFVec3b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3b * >(argp2);
  result = (SbBool)((SoMFVec3b const *)arg1)->operator !=((SoMFVec3b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3b *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_startEditing" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  result = (SbVec3b *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_finishEditing" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  SbVec3b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "3"" of type '" "SbVec3b const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3b * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec3b const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  SbVec3b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "3"" of type '" "SbVec3b *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3b * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "3"" of type '" "int8_t const *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,(int8_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_setValuesPointer" "', argument " "3"" of type '" "int8_t *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3b_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3b_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3b::setValuesPointer(int const,SbVec3b const *)\n"
    "    SoMFVec3b::setValuesPointer(int const,SbVec3b *)\n"
    "    SoMFVec3b::setValuesPointer(int const,int8_t const *)\n"
    "    SoMFVec3b::setValuesPointer(int const,int8_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3b_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec3b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int8_t (*arg4)[3] = (int8_t (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValues" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_3__signed_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3b_setValues" "', argument " "4"" of type '" "int8_t const [][3]""'"); 
  } 
  arg4 = reinterpret_cast< int8_t (*)[3] >(argp4);
  (arg1)->setValues(arg2,arg3,(int8_t const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3b_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3b, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3b_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_3__signed_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3b_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3b_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3b::setValues(int const,int const,SbVec3b const *)\n"
    "    SoMFVec3b::setValues(int,int,int8_t const [][3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  int8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  signed char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_set1Value" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3b_set1Value" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3b_set1Value" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  ecode5 = SWIG_AsVal_signed_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec3b_set1Value" "', argument " "5"" of type '" "int8_t""'");
  } 
  arg5 = static_cast< int8_t >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_set1Value" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3b_set1Value" "', argument " "3"" of type '" "int8_t const [3]""'"); 
  } 
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->set1Value(arg2,(int8_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3b_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3b_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_signed_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec3b_set1Value__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3b_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3b::set1Value(int const,SbVec3b)\n"
    "    SoMFVec3b::set1Value(int,int8_t,int8_t,int8_t)\n"
    "    SoMFVec3b::set1Value(int,int8_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValue" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3b_setValue" "', argument " "1"" of type '" "SoMFVec3b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3b_setValue" "', argument " "2"" of type '" "int8_t const [3]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3b_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec3b_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3b::setValue(SbVec3b)\n"
    "    SoMFVec3b::setValue(int8_t,int8_t,int8_t)\n"
    "    SoMFVec3b::setValue(int8_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec3b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec3b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec3b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec3s", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec3s *)new SoMFVec3s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec3s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec3s" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec3s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec3s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_getTypeId" "', argument " "1"" of type '" "SoMFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  result = ((SoMFVec3s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_copyFrom" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_isSame" "', argument " "1"" of type '" "SoMFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec3s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_getValues" "', argument " "1"" of type '" "SoMFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3s *)((SoMFVec3s const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_find" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_find" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_find" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3s_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec3s const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_find" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_find" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_find" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  result = (int)(arg1)->find((SbVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3s_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3s_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec3s_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3s_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3s::find(SbVec3s const &,SbBool)\n"
    "    SoMFVec3s::find(SbVec3s const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3s *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValues" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3s_setValues" "', argument " "4"" of type '" "SbVec3s const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec3s * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec3s const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_set1Value" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3s_set1Value" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_set1Value" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  (arg1)->set1Value(arg2,(SbVec3s const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValue" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s_setValue" "', argument " "2"" of type '" "SbVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  (arg1)->setValue((SbVec3s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SoMFVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s___eq__" "', argument " "1"" of type '" "SoMFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s___eq__" "', argument " "2"" of type '" "SoMFVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s___eq__" "', argument " "2"" of type '" "SoMFVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3s * >(argp2);
  result = (SbBool)((SoMFVec3s const *)arg1)->operator ==((SoMFVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  SoMFVec3s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s___ne__" "', argument " "1"" of type '" "SoMFVec3s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s___ne__" "', argument " "2"" of type '" "SoMFVec3s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3s___ne__" "', argument " "2"" of type '" "SoMFVec3s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3s * >(argp2);
  result = (SbBool)((SoMFVec3s const *)arg1)->operator !=((SoMFVec3s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_startEditing" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  result = (SbVec3s *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_finishEditing" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "3"" of type '" "SbVec3s const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec3s const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  SbVec3s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "3"" of type '" "SbVec3s *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3s_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3s_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3s::setValuesPointer(int const,SbVec3s const *)\n"
    "    SoMFVec3s::setValuesPointer(int const,SbVec3s *)\n"
    "    SoMFVec3s::setValuesPointer(int const,short const *)\n"
    "    SoMFVec3s::setValuesPointer(int const,short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3s_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec3s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  short (*arg4)[3] = (short (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValues" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_3__short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3s_setValues" "', argument " "4"" of type '" "short const [][3]""'"); 
  } 
  arg4 = reinterpret_cast< short (*)[3] >(argp4);
  (arg1)->setValues(arg2,arg3,(short const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3s_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3s, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3s_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_3__short, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3s_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3s_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3s::setValues(int const,int const,SbVec3s const *)\n"
    "    SoMFVec3s::setValues(int,int,short const [][3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_set1Value" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3s_set1Value" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3s_set1Value" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec3s_set1Value" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_set1Value" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3s_set1Value" "', argument " "3"" of type '" "short const [3]""'"); 
  } 
  arg3 = reinterpret_cast< short * >(argp3);
  (arg1)->set1Value(arg2,(short const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3s_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3s_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec3s_set1Value__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3s_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3s::set1Value(int const,SbVec3s const &)\n"
    "    SoMFVec3s::set1Value(int,short,short,short)\n"
    "    SoMFVec3s::set1Value(int,short const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValue" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3s_setValue" "', argument " "1"" of type '" "SoMFVec3s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3s_setValue" "', argument " "2"" of type '" "short const [3]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3s_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec3s_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3s::setValue(SbVec3s const &)\n"
    "    SoMFVec3s::setValue(short,short,short)\n"
    "    SoMFVec3s::setValue(short const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec3s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec3s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec3s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec3i32", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec3i32 *)new SoMFVec3i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec3i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec3i32" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec3i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec3i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_getTypeId" "', argument " "1"" of type '" "SoMFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  result = ((SoMFVec3i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_copyFrom" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_isSame" "', argument " "1"" of type '" "SoMFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec3i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_getValues" "', argument " "1"" of type '" "SoMFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3i32 *)((SoMFVec3i32 const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_find" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_find" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_find" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3i32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec3i32 const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_find" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_find" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_find" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  result = (int)(arg1)->find((SbVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3i32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3i32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec3i32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3i32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3i32::find(SbVec3i32 const &,SbBool)\n"
    "    SoMFVec3i32::find(SbVec3i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3i32 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValues" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3i32_setValues" "', argument " "4"" of type '" "SbVec3i32 const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec3i32 * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec3i32 const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_set1Value" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3i32_set1Value" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_set1Value" "', argument " "3"" of type '" "SbVec3i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  (arg1)->set1Value(arg2,(SbVec3i32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SbVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValue" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32_setValue" "', argument " "2"" of type '" "SbVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3i32 * >(argp2);
  (arg1)->setValue((SbVec3i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SoMFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32___eq__" "', argument " "1"" of type '" "SoMFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32___eq__" "', argument " "2"" of type '" "SoMFVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32___eq__" "', argument " "2"" of type '" "SoMFVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3i32 * >(argp2);
  result = (SbBool)((SoMFVec3i32 const *)arg1)->operator ==((SoMFVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  SoMFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32___ne__" "', argument " "1"" of type '" "SoMFVec3i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32___ne__" "', argument " "2"" of type '" "SoMFVec3i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3i32___ne__" "', argument " "2"" of type '" "SoMFVec3i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3i32 * >(argp2);
  result = (SbBool)((SoMFVec3i32 const *)arg1)->operator !=((SoMFVec3i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_startEditing" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  result = (SbVec3i32 *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_finishEditing" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "3"" of type '" "SbVec3i32 const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec3i32 const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  SbVec3i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "3"" of type '" "SbVec3i32 *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(int32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3i32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3i32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3i32::setValuesPointer(int const,SbVec3i32 const *)\n"
    "    SoMFVec3i32::setValuesPointer(int const,SbVec3i32 *)\n"
    "    SoMFVec3i32::setValuesPointer(int const,int32_t const *)\n"
    "    SoMFVec3i32::setValuesPointer(int const,int32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3i32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec3i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int32_t (*arg4)[3] = (int32_t (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValues" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_3__int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec3i32_setValues" "', argument " "4"" of type '" "int32_t const [][3]""'"); 
  } 
  arg4 = reinterpret_cast< int32_t (*)[3] >(argp4);
  (arg1)->setValues(arg2,arg3,(int32_t const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3i32_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3i32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3i32_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_3__int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec3i32_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3i32_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3i32::setValues(int const,int const,SbVec3i32 const *)\n"
    "    SoMFVec3i32::setValues(int,int,int32_t const [][3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_set1Value" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3i32_set1Value" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3i32_set1Value" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec3i32_set1Value" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_set1Value" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3i32_set1Value" "', argument " "3"" of type '" "int32_t const [3]""'"); 
  } 
  arg3 = reinterpret_cast< int32_t * >(argp3);
  (arg1)->set1Value(arg2,(int32_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3i32_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3i32_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec3i32_set1Value__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3i32_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3i32::set1Value(int const,SbVec3i32 const &)\n"
    "    SoMFVec3i32::set1Value(int,int32_t,int32_t,int32_t)\n"
    "    SoMFVec3i32::set1Value(int,int32_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValue" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3i32_setValue" "', argument " "1"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3i32_setValue" "', argument " "2"" of type '" "int32_t const [3]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3i32_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec3i32_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3i32::setValue(SbVec3i32 const &)\n"
    "    SoMFVec3i32::setValue(int32_t,int32_t,int32_t)\n"
    "    SoMFVec3i32::setValue(int32_t const [3])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec3i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec3i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec3i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec3d", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec3d *)new SoMFVec3d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec3d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec3d" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec3d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec3d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_getTypeId" "', argument " "1"" of type '" "SoMFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  result = ((SoMFVec3d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_copyFrom" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_isSame" "', argument " "1"" of type '" "SoMFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec3d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_find" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_find" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_find" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec3d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_find" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_find" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_find" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (int)(arg1)->find((SbVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3d_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec3d_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::find(SbVec3d const &,SbBool)\n"
    "    SoMFVec3d::find(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec3d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValues" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      if (len > 0) {
        arg4 = new SbVec3d[len];
        for (int i = 0; i < len; i++) {
          SbVec3d * VecPtr = NULL;
          PyObject * item = PyList_GetItem(swig_obj[3],i);
          SWIG_ConvertPtr(item, (void **) &VecPtr, SWIGTYPE_p_SbVec3d, 1);
          if (VecPtr != NULL) {
            arg4[i] = *VecPtr; 
          }
        }
      } else {
        arg4 = NULL; 
      }
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValues(arg2,arg3,(SbVec3d const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete[] arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_set1Value" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d_set1Value" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_set1Value" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->set1Value(arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValue" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->setValue((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SoMFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d___eq__" "', argument " "1"" of type '" "SoMFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d___eq__" "', argument " "2"" of type '" "SoMFVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d___eq__" "', argument " "2"" of type '" "SoMFVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3d * >(argp2);
  result = (SbBool)((SoMFVec3d const *)arg1)->operator ==((SoMFVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SoMFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d___ne__" "', argument " "1"" of type '" "SoMFVec3d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d___ne__" "', argument " "2"" of type '" "SoMFVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d___ne__" "', argument " "2"" of type '" "SoMFVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3d * >(argp2);
  result = (SbBool)((SoMFVec3d const *)arg1)->operator !=((SoMFVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_startEditing" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  result = (SbVec3d *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_finishEditing" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "3"" of type '" "SbVec3d const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec3d const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "3"" of type '" "SbVec3d *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d_setValuesPointer" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3d_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3d_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3d_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3d_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::setValuesPointer(int const,SbVec3d const *)\n"
    "    SoMFVec3d::setValuesPointer(int const,SbVec3d *)\n"
    "    SoMFVec3d::setValuesPointer(int const,double const *)\n"
    "    SoMFVec3d::setValuesPointer(int const,double *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec3d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  double (*arg4)[3] = (double (*)[3])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double (*temp4)[3] ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValues" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int len;
    if (PySequence_Check(swig_obj[3])) {
      len = PySequence_Length(swig_obj[3]);
      temp4 = (double (*)[3]) malloc(len*3*sizeof(double));
      convert_SoMFVec3d_array(swig_obj[3], len, temp4);  
      arg4 = temp4;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
      arg4 = NULL;
    }
  }
  (arg1)->setValues(arg2,arg3,(double const (*)[3])arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      free(arg4); 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PySequence_Check(argv[3])) {
              if (PySequence_Size(argv[3]) == 0) {
                _v = 1; 
              }
              else {
                PyObject * obj = PySequence_GetItem(argv[3], 0);
                void * ptr;
                if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec3d, 0) != -1) {
                  _v = 1; 
                }
                else {
                  _v = 0; 
                }
                Py_DECREF(obj);
              }
            }
            else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec3d_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if(PySequence_Check(argv[3]) && PySequence_Size(argv[3]) > 0 ){
              PyObject * obj = PySequence_GetItem(argv[3], 0);
              void * ptr;
              if (SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_SbVec3d, 0) == -1) {
                _v = 1; 
              }
              else {
                _v = 0; 
              }
              Py_DECREF(obj);
            } else {
              _v = 0; 
            }
          }
          if (_v) {
            return _wrap_SoMFVec3d_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::setValues(int const,int const,SbVec3d const *)\n"
    "    SoMFVec3d::setValues(int,int,double const [][3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_set1Value" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_set1Value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3d_set1Value" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec3d_set1Value" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->set1Value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double temp3[3] ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_set1Value" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    convert_SbVec3d_array(swig_obj[2], temp3);
    arg3 = temp3;
  }
  (arg1)->set1Value(arg2,(double const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_set1Value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec3d_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void * ptr;
          _v = (PySequence_Check(argv[2]) && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_SoMFVec3d, 0) == -1) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoMFVec3d_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec3d_set1Value__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::set1Value(int const,SbVec3d const &)\n"
    "    SoMFVec3d::set1Value(int,double,double,double)\n"
    "    SoMFVec3d::set1Value(int,double const [3])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValue" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec3d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[3] ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValue" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  {
    convert_SbVec3d_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d___getitem__" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3d *) &SoMFVec3d___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec3d___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d___setitem__" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec3d___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec3d___setitem__" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec3d___setitem__" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  SoMFVec3d___setitem__(arg1,arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  SoMFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_setValue" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec3d_setValue" "', argument " "2"" of type '" "SoMFVec3d const *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3d * >(argp2);
  SoMFVec3d_setValue__SWIG_3(arg1,(SoMFVec3d const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_setValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void * ptr;
        _v = (PySequence_Check(argv[1]) && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_SoMFVec3d, 0) == -1) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoMFVec3d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec3d_setValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMFVec3d_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::setValue(SbVec3d const &)\n"
    "    SoMFVec3d::setValue(double,double,double)\n"
    "    SoMFVec3d::setValue(double const [3])\n"
    "    SoMFVec3d::setValue(SoMFVec3d const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_getValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  SbVec3d *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_getValues" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec3d_getValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbVec3d *)SoMFVec3d___getValuesHelper____SWIG_0(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec3d * VecPtr = new SbVec3d(result[i]);
        PyObject * obj = SWIG_NewPointerObj(VecPtr, SWIGTYPE_p_SbVec3d, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_getValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec3d *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  SbVec3d *result = 0 ;
  
  {
    arg2 = &temp2;
    *arg2 = 0;
  }
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec3d_getValues" "', argument " "1"" of type '" "SoMFVec3d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec3d * >(argp1);
  result = (SbVec3d *)SoMFVec3d___getValuesHelper____SWIG_0(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  {
    Py_XDECREF(resultobj); /* free up any previous result */
    resultobj = PyList_New(*arg2);
    if (result) {
      for (int i = 0; i < *arg2; i++) {
        SbVec3d * VecPtr = new SbVec3d(result[i]);
        PyObject * obj = SWIG_NewPointerObj(VecPtr, SWIGTYPE_p_SbVec3d, 1);
        PyList_SetItem(resultobj, i, obj);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec3d_getValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec3d_getValues", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoMFVec3d_getValues__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec3d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoMFVec3d_getValues__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec3d_getValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec3d::__getValuesHelper__(int &,int)\n"
    "    SoMFVec3d::__getValuesHelper__(int &)\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec3d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec3d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4b", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4b *)new SoMFVec4b();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4b, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4b" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4b::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4b::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_getTypeId" "', argument " "1"" of type '" "SoMFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  result = ((SoMFVec4b const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_copyFrom" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_isSame" "', argument " "1"" of type '" "SoMFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4b const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_getValues" "', argument " "1"" of type '" "SoMFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4b *)((SoMFVec4b const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_find" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_find" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_find" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4b_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_find" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_find" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_find" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4b_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4b_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4b_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4b_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4b::find(SbVec4b,SbBool)\n"
    "    SoMFVec4b::find(SbVec4b)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4b *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValues" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4b_setValues" "', argument " "4"" of type '" "SbVec4b const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4b * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4b const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  SbVec4b arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_set1Value" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_set1Value" "', argument " "3"" of type '" "SbVec4b""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_set1Value" "', argument " "3"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SbVec4b arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValue" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4b,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_setValue" "', argument " "2"" of type '" "SbVec4b""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b_setValue" "', argument " "2"" of type '" "SbVec4b""'");
    } else {
      SbVec4b * temp = reinterpret_cast< SbVec4b * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SoMFVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b___eq__" "', argument " "1"" of type '" "SoMFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b___eq__" "', argument " "2"" of type '" "SoMFVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b___eq__" "', argument " "2"" of type '" "SoMFVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4b * >(argp2);
  result = (SbBool)((SoMFVec4b const *)arg1)->operator ==((SoMFVec4b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  SoMFVec4b *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b___ne__" "', argument " "1"" of type '" "SoMFVec4b const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4b,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b___ne__" "', argument " "2"" of type '" "SoMFVec4b const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4b___ne__" "', argument " "2"" of type '" "SoMFVec4b const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4b * >(argp2);
  result = (SbBool)((SoMFVec4b const *)arg1)->operator !=((SoMFVec4b const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4b *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_startEditing" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  result = (SbVec4b *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4b, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_finishEditing" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  SbVec4b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "3"" of type '" "SbVec4b const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4b * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4b const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  SbVec4b *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4b, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "3"" of type '" "SbVec4b *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4b * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "3"" of type '" "int8_t const *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,(int8_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_setValuesPointer" "', argument " "3"" of type '" "int8_t *""'"); 
  }
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4b_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4b, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4b_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4b::setValuesPointer(int const,SbVec4b const *)\n"
    "    SoMFVec4b::setValuesPointer(int const,SbVec4b *)\n"
    "    SoMFVec4b::setValuesPointer(int const,int8_t const *)\n"
    "    SoMFVec4b::setValuesPointer(int const,int8_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4b_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4b::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int8_t (*arg4)[4] = (int8_t (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValues" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4b_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__signed_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4b_setValues" "', argument " "4"" of type '" "int8_t const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< int8_t (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(int8_t const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4b_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4b, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4b_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__signed_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4b_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4b_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4b::setValues(int const,int const,SbVec4b const *)\n"
    "    SoMFVec4b::setValues(int,int,int8_t const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  int8_t arg5 ;
  int8_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  signed char val5 ;
  int ecode5 = 0 ;
  signed char val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_set1Value" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4b_set1Value" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4b_set1Value" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  ecode5 = SWIG_AsVal_signed_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4b_set1Value" "', argument " "5"" of type '" "int8_t""'");
  } 
  arg5 = static_cast< int8_t >(val5);
  ecode6 = SWIG_AsVal_signed_SS_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4b_set1Value" "', argument " "6"" of type '" "int8_t""'");
  } 
  arg6 = static_cast< int8_t >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int arg2 ;
  int8_t *arg3 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_set1Value" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4b_set1Value" "', argument " "3"" of type '" "int8_t const [4]""'"); 
  } 
  arg3 = reinterpret_cast< int8_t * >(argp3);
  (arg1)->set1Value(arg2,(int8_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4b_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_signed_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4b_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_signed_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_signed_SS_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4b_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4b_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4b::set1Value(int const,SbVec4b)\n"
    "    SoMFVec4b::set1Value(int,int8_t,int8_t,int8_t,int8_t)\n"
    "    SoMFVec4b::set1Value(int,int8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int8_t arg2 ;
  int8_t arg3 ;
  int8_t arg4 ;
  int8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  signed char val3 ;
  int ecode3 = 0 ;
  signed char val4 ;
  int ecode4 = 0 ;
  signed char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValue" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4b_setValue" "', argument " "2"" of type '" "int8_t""'");
  } 
  arg2 = static_cast< int8_t >(val2);
  ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4b_setValue" "', argument " "3"" of type '" "int8_t""'");
  } 
  arg3 = static_cast< int8_t >(val3);
  ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4b_setValue" "', argument " "4"" of type '" "int8_t""'");
  } 
  arg4 = static_cast< int8_t >(val4);
  ecode5 = SWIG_AsVal_signed_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4b_setValue" "', argument " "5"" of type '" "int8_t""'");
  } 
  arg5 = static_cast< int8_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4b *arg1 = 0 ;
  int8_t *arg2 = (int8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4b, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4b_setValue" "', argument " "1"" of type '" "SoMFVec4b *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4b * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_signed_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4b_setValue" "', argument " "2"" of type '" "int8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int8_t * >(argp2);
  (arg1)->setValue((int8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4b_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4b_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4b, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4b_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_signed_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4b_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4b, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_signed_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_signed_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_signed_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_signed_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4b_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4b_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4b::setValue(SbVec4b)\n"
    "    SoMFVec4b::setValue(int8_t,int8_t,int8_t,int8_t)\n"
    "    SoMFVec4b::setValue(int8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4b_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4b, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4b_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4ub(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4ub", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4ub *)new SoMFVec4ub();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4ub, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4ub(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4ub" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4ub::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4ub::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_getTypeId" "', argument " "1"" of type '" "SoMFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  result = ((SoMFVec4ub const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_copyFrom" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_isSame" "', argument " "1"" of type '" "SoMFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4ub const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_getValues" "', argument " "1"" of type '" "SoMFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ub *)((SoMFVec4ub const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_find" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_find" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_find" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ub_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_find" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_find" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_find" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->find(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ub_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ub_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4ub_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ub_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ub::find(SbVec4ub,SbBool)\n"
    "    SoMFVec4ub::find(SbVec4ub)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4ub *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValues" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ub_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4ub_setValues" "', argument " "4"" of type '" "SbVec4ub const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4ub * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4ub const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  SbVec4ub arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_set1Value" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_set1Value" "', argument " "3"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_set1Value" "', argument " "3"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->set1Value(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SbVec4ub arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValue" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ub,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ub""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub_setValue" "', argument " "2"" of type '" "SbVec4ub""'");
    } else {
      SbVec4ub * temp = reinterpret_cast< SbVec4ub * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setValue(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SoMFVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub___eq__" "', argument " "1"" of type '" "SoMFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub___eq__" "', argument " "2"" of type '" "SoMFVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub___eq__" "', argument " "2"" of type '" "SoMFVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4ub * >(argp2);
  result = (SbBool)((SoMFVec4ub const *)arg1)->operator ==((SoMFVec4ub const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  SoMFVec4ub *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub___ne__" "', argument " "1"" of type '" "SoMFVec4ub const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4ub,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub___ne__" "', argument " "2"" of type '" "SoMFVec4ub const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ub___ne__" "', argument " "2"" of type '" "SoMFVec4ub const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4ub * >(argp2);
  result = (SbBool)((SoMFVec4ub const *)arg1)->operator !=((SoMFVec4ub const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ub *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_startEditing" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  result = (SbVec4ub *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ub, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_finishEditing" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  SbVec4ub *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "3"" of type '" "SbVec4ub const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4ub * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4ub const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  SbVec4ub *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "3"" of type '" "SbVec4ub *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4ub * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  uint8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "3"" of type '" "uint8_t const *""'"); 
  }
  arg3 = reinterpret_cast< uint8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,(uint8_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  uint8_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_setValuesPointer" "', argument " "3"" of type '" "uint8_t *""'"); 
  }
  arg3 = reinterpret_cast< uint8_t * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ub_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4ub, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4ub, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ub_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ub::setValuesPointer(int const,SbVec4ub const *)\n"
    "    SoMFVec4ub::setValuesPointer(int const,SbVec4ub *)\n"
    "    SoMFVec4ub::setValuesPointer(int const,uint8_t const *)\n"
    "    SoMFVec4ub::setValuesPointer(int const,uint8_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ub_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4ub::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  uint8_t (*arg4)[4] = (uint8_t (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValues" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ub_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4ub_setValues" "', argument " "4"" of type '" "uint8_t const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< uint8_t (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(uint8_t const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ub_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4ub, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4ub_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4ub_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ub_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ub::setValues(int const,int const,SbVec4ub const *)\n"
    "    SoMFVec4ub::setValues(int,int,uint8_t const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  uint8_t arg3 ;
  uint8_t arg4 ;
  uint8_t arg5 ;
  uint8_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_set1Value" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ub_set1Value" "', argument " "3"" of type '" "uint8_t""'");
  } 
  arg3 = static_cast< uint8_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4ub_set1Value" "', argument " "4"" of type '" "uint8_t""'");
  } 
  arg4 = static_cast< uint8_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4ub_set1Value" "', argument " "5"" of type '" "uint8_t""'");
  } 
  arg5 = static_cast< uint8_t >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4ub_set1Value" "', argument " "6"" of type '" "uint8_t""'");
  } 
  arg6 = static_cast< uint8_t >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  int arg2 ;
  uint8_t *arg3 = (uint8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_set1Value" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ub_set1Value" "', argument " "3"" of type '" "uint8_t const [4]""'"); 
  } 
  arg3 = reinterpret_cast< uint8_t * >(argp3);
  (arg1)->set1Value(arg2,(uint8_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ub_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ub_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4ub_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ub_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ub::set1Value(int const,SbVec4ub)\n"
    "    SoMFVec4ub::set1Value(int,uint8_t,uint8_t,uint8_t,uint8_t)\n"
    "    SoMFVec4ub::set1Value(int,uint8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  uint8_t arg2 ;
  uint8_t arg3 ;
  uint8_t arg4 ;
  uint8_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValue" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ub_setValue" "', argument " "2"" of type '" "uint8_t""'");
  } 
  arg2 = static_cast< uint8_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ub_setValue" "', argument " "3"" of type '" "uint8_t""'");
  } 
  arg3 = static_cast< uint8_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4ub_setValue" "', argument " "4"" of type '" "uint8_t""'");
  } 
  arg4 = static_cast< uint8_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4ub_setValue" "', argument " "5"" of type '" "uint8_t""'");
  } 
  arg5 = static_cast< uint8_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ub *arg1 = 0 ;
  uint8_t *arg2 = (uint8_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ub, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ub_setValue" "', argument " "1"" of type '" "SoMFVec4ub *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ub * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ub_setValue" "', argument " "2"" of type '" "uint8_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint8_t * >(argp2);
  (arg1)->setValue((uint8_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ub_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ub_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ub, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ub_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ub_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ub, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4ub_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ub_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ub::setValue(SbVec4ub)\n"
    "    SoMFVec4ub::setValue(uint8_t,uint8_t,uint8_t,uint8_t)\n"
    "    SoMFVec4ub::setValue(uint8_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4ub_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4ub, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4ub_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4s", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4s *)new SoMFVec4s();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4s(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4s" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4s::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4s::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_getTypeId" "', argument " "1"" of type '" "SoMFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  result = ((SoMFVec4s const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_copyFrom" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_isSame" "', argument " "1"" of type '" "SoMFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4s const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_getValues" "', argument " "1"" of type '" "SoMFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4s *)((SoMFVec4s const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_find" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_find" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_find" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4s_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4s const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_find" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_find" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_find" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  result = (int)(arg1)->find((SbVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4s_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4s_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4s_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4s_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4s::find(SbVec4s const &,SbBool)\n"
    "    SoMFVec4s::find(SbVec4s const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4s *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValues" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4s_setValues" "', argument " "4"" of type '" "SbVec4s const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4s * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4s const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  SbVec4s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_set1Value" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4s_set1Value" "', argument " "3"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_set1Value" "', argument " "3"" of type '" "SbVec4s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4s * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4s const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SbVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValue" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s_setValue" "', argument " "2"" of type '" "SbVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4s * >(argp2);
  (arg1)->setValue((SbVec4s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SoMFVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s___eq__" "', argument " "1"" of type '" "SoMFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s___eq__" "', argument " "2"" of type '" "SoMFVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s___eq__" "', argument " "2"" of type '" "SoMFVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4s * >(argp2);
  result = (SbBool)((SoMFVec4s const *)arg1)->operator ==((SoMFVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  SoMFVec4s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s___ne__" "', argument " "1"" of type '" "SoMFVec4s const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s___ne__" "', argument " "2"" of type '" "SoMFVec4s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4s___ne__" "', argument " "2"" of type '" "SoMFVec4s const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4s * >(argp2);
  result = (SbBool)((SoMFVec4s const *)arg1)->operator !=((SoMFVec4s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_startEditing" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  result = (SbVec4s *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_finishEditing" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  SbVec4s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "3"" of type '" "SbVec4s const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4s * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4s const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  SbVec4s *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "3"" of type '" "SbVec4s *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4s * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (short*)malloc(len*sizeof(short));
      convert_SoMFShort_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4s_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4s, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4s_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4s::setValuesPointer(int const,SbVec4s const *)\n"
    "    SoMFVec4s::setValuesPointer(int const,SbVec4s *)\n"
    "    SoMFVec4s::setValuesPointer(int const,short const *)\n"
    "    SoMFVec4s::setValuesPointer(int const,short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4s_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4s::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  short (*arg4)[4] = (short (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValues" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4s_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4s_setValues" "', argument " "4"" of type '" "short const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< short (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(short const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4s_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4s, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4s_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__short, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4s_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4s_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4s::setValues(int const,int const,SbVec4s const *)\n"
    "    SoMFVec4s::setValues(int,int,short const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_set1Value" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4s_set1Value" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4s_set1Value" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4s_set1Value" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  ecode6 = SWIG_AsVal_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4s_set1Value" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  int arg2 ;
  short *arg3 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_set1Value" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4s_set1Value" "', argument " "3"" of type '" "short const [4]""'"); 
  } 
  arg3 = reinterpret_cast< short * >(argp3);
  (arg1)->set1Value(arg2,(short const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4s_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4s_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4s_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4s_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4s::set1Value(int const,SbVec4s const &)\n"
    "    SoMFVec4s::set1Value(int,short,short,short,short)\n"
    "    SoMFVec4s::set1Value(int,short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  short arg2 ;
  short arg3 ;
  short arg4 ;
  short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValue" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4s_setValue" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4s_setValue" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4s_setValue" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  ecode5 = SWIG_AsVal_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4s_setValue" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4s *arg1 = 0 ;
  short *arg2 = (short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4s_setValue" "', argument " "1"" of type '" "SoMFVec4s *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4s * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4s_setValue" "', argument " "2"" of type '" "short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< short * >(argp2);
  (arg1)->setValue((short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4s_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4s_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4s_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4s_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4s, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4s_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4s_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4s::setValue(SbVec4s const &)\n"
    "    SoMFVec4s::setValue(short,short,short,short)\n"
    "    SoMFVec4s::setValue(short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4s_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4s_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4us(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4us", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4us *)new SoMFVec4us();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4us, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4us(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4us" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4us::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4us::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_getTypeId" "', argument " "1"" of type '" "SoMFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  result = ((SoMFVec4us const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_copyFrom" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_isSame" "', argument " "1"" of type '" "SoMFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4us const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_getValues" "', argument " "1"" of type '" "SoMFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4us *)((SoMFVec4us const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_find" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_find" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_find" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4us_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4us const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_find" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_find" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_find" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  result = (int)(arg1)->find((SbVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4us_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4us_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4us_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4us_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4us::find(SbVec4us const &,SbBool)\n"
    "    SoMFVec4us::find(SbVec4us const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4us *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValues" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4us_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4us_setValues" "', argument " "4"" of type '" "SbVec4us const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4us * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4us const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  SbVec4us *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_set1Value" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4us_set1Value" "', argument " "3"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_set1Value" "', argument " "3"" of type '" "SbVec4us const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4us * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4us const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SbVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValue" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us_setValue" "', argument " "2"" of type '" "SbVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4us * >(argp2);
  (arg1)->setValue((SbVec4us const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SoMFVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us___eq__" "', argument " "1"" of type '" "SoMFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us___eq__" "', argument " "2"" of type '" "SoMFVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us___eq__" "', argument " "2"" of type '" "SoMFVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4us * >(argp2);
  result = (SbBool)((SoMFVec4us const *)arg1)->operator ==((SoMFVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  SoMFVec4us *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us___ne__" "', argument " "1"" of type '" "SoMFVec4us const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4us,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us___ne__" "', argument " "2"" of type '" "SoMFVec4us const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4us___ne__" "', argument " "2"" of type '" "SoMFVec4us const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4us * >(argp2);
  result = (SbBool)((SoMFVec4us const *)arg1)->operator !=((SoMFVec4us const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4us *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_startEditing" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  result = (SbVec4us *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4us, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_finishEditing" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  SbVec4us *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "3"" of type '" "SbVec4us const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4us * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4us const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  SbVec4us *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4us, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "3"" of type '" "SbVec4us *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4us * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  unsigned short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (unsigned short*)malloc(len*sizeof(unsigned short));
      convert_SoMFUShort_array(swig_obj[2], len, temp3);
      
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(unsigned short const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  unsigned short *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (unsigned short*)malloc(len*sizeof(unsigned short));
      convert_SoMFUShort_array(swig_obj[2], len, temp3);
      
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4us_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4us, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4us, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4us_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4us::setValuesPointer(int const,SbVec4us const *)\n"
    "    SoMFVec4us::setValuesPointer(int const,SbVec4us *)\n"
    "    SoMFVec4us::setValuesPointer(int const,unsigned short const *)\n"
    "    SoMFVec4us::setValuesPointer(int const,unsigned short *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4us_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4us::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  unsigned short (*arg4)[4] = (unsigned short (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValues" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4us_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4us_setValues" "', argument " "4"" of type '" "unsigned short const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< unsigned short (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(unsigned short const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4us_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4us, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4us_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__unsigned_short, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4us_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4us_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4us::setValues(int const,int const,SbVec4us const *)\n"
    "    SoMFVec4us::setValues(int,int,unsigned short const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  unsigned short arg5 ;
  unsigned short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_set1Value" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4us_set1Value" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4us_set1Value" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4us_set1Value" "', argument " "5"" of type '" "unsigned short""'");
  } 
  arg5 = static_cast< unsigned short >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4us_set1Value" "', argument " "6"" of type '" "unsigned short""'");
  } 
  arg6 = static_cast< unsigned short >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  int arg2 ;
  unsigned short *arg3 = (unsigned short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_set1Value" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4us_set1Value" "', argument " "3"" of type '" "unsigned short const [4]""'"); 
  } 
  arg3 = reinterpret_cast< unsigned short * >(argp3);
  (arg1)->set1Value(arg2,(unsigned short const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4us_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4us_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4us_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4us_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4us::set1Value(int const,SbVec4us const &)\n"
    "    SoMFVec4us::set1Value(int,unsigned short,unsigned short,unsigned short,unsigned short)\n"
    "    SoMFVec4us::set1Value(int,unsigned short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValue" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4us_setValue" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4us_setValue" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4us_setValue" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4us_setValue" "', argument " "5"" of type '" "unsigned short""'");
  } 
  arg5 = static_cast< unsigned short >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4us *arg1 = 0 ;
  unsigned short *arg2 = (unsigned short *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4us, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4us_setValue" "', argument " "1"" of type '" "SoMFVec4us *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4us * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4us_setValue" "', argument " "2"" of type '" "unsigned short const [4]""'"); 
  } 
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  (arg1)->setValue((unsigned short const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4us_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4us_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4us, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4us_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4us_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4us, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4us_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4us_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4us::setValue(SbVec4us const &)\n"
    "    SoMFVec4us::setValue(unsigned short,unsigned short,unsigned short,unsigned short)\n"
    "    SoMFVec4us::setValue(unsigned short const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4us_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4us, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4us_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4i32", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4i32 *)new SoMFVec4i32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4i32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4i32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4i32" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4i32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4i32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_getTypeId" "', argument " "1"" of type '" "SoMFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  result = ((SoMFVec4i32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_copyFrom" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_isSame" "', argument " "1"" of type '" "SoMFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4i32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_getValues" "', argument " "1"" of type '" "SoMFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4i32 *)((SoMFVec4i32 const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_find" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_find" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_find" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4i32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4i32 const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_find" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_find" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_find" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  result = (int)(arg1)->find((SbVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4i32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4i32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4i32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4i32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4i32::find(SbVec4i32 const &,SbBool)\n"
    "    SoMFVec4i32::find(SbVec4i32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4i32 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValues" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4i32_setValues" "', argument " "4"" of type '" "SbVec4i32 const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4i32 * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4i32 const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  SbVec4i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_set1Value" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4i32_set1Value" "', argument " "3"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_set1Value" "', argument " "3"" of type '" "SbVec4i32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4i32 * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4i32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SbVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValue" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32_setValue" "', argument " "2"" of type '" "SbVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4i32 * >(argp2);
  (arg1)->setValue((SbVec4i32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SoMFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32___eq__" "', argument " "1"" of type '" "SoMFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32___eq__" "', argument " "2"" of type '" "SoMFVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32___eq__" "', argument " "2"" of type '" "SoMFVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4i32 * >(argp2);
  result = (SbBool)((SoMFVec4i32 const *)arg1)->operator ==((SoMFVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  SoMFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32___ne__" "', argument " "1"" of type '" "SoMFVec4i32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4i32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32___ne__" "', argument " "2"" of type '" "SoMFVec4i32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4i32___ne__" "', argument " "2"" of type '" "SoMFVec4i32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4i32 * >(argp2);
  result = (SbBool)((SoMFVec4i32 const *)arg1)->operator !=((SoMFVec4i32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_startEditing" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  result = (SbVec4i32 *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_finishEditing" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  SbVec4i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "3"" of type '" "SbVec4i32 const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4i32 const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  SbVec4i32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "3"" of type '" "SbVec4i32 *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4i32 * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(int32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (int32_t*)malloc(len*sizeof(int32_t));
      convert_SoMFInt32_array(swig_obj[2], len, temp3);
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4i32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4i32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4i32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4i32::setValuesPointer(int const,SbVec4i32 const *)\n"
    "    SoMFVec4i32::setValuesPointer(int const,SbVec4i32 *)\n"
    "    SoMFVec4i32::setValuesPointer(int const,int32_t const *)\n"
    "    SoMFVec4i32::setValuesPointer(int const,int32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4i32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4i32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int32_t (*arg4)[4] = (int32_t (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValues" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4i32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4i32_setValues" "', argument " "4"" of type '" "int32_t const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< int32_t (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(int32_t const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4i32_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4i32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4i32_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4i32_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4i32_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4i32::setValues(int const,int const,SbVec4i32 const *)\n"
    "    SoMFVec4i32::setValues(int,int,int32_t const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  int32_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_set1Value" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4i32_set1Value" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4i32_set1Value" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4i32_set1Value" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4i32_set1Value" "', argument " "6"" of type '" "int32_t""'");
  } 
  arg6 = static_cast< int32_t >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int arg2 ;
  int32_t *arg3 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_set1Value" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4i32_set1Value" "', argument " "3"" of type '" "int32_t const [4]""'"); 
  } 
  arg3 = reinterpret_cast< int32_t * >(argp3);
  (arg1)->set1Value(arg2,(int32_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4i32_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4i32_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4i32_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4i32_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4i32::set1Value(int const,SbVec4i32 const &)\n"
    "    SoMFVec4i32::set1Value(int,int32_t,int32_t,int32_t,int32_t)\n"
    "    SoMFVec4i32::set1Value(int,int32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  int32_t arg4 ;
  int32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValue" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4i32_setValue" "', argument " "2"" of type '" "int32_t""'");
  } 
  arg2 = static_cast< int32_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4i32_setValue" "', argument " "3"" of type '" "int32_t""'");
  } 
  arg3 = static_cast< int32_t >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4i32_setValue" "', argument " "4"" of type '" "int32_t""'");
  } 
  arg4 = static_cast< int32_t >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4i32_setValue" "', argument " "5"" of type '" "int32_t""'");
  } 
  arg5 = static_cast< int32_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4i32 *arg1 = 0 ;
  int32_t *arg2 = (int32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4i32_setValue" "', argument " "1"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4i32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4i32_setValue" "', argument " "2"" of type '" "int32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< int32_t * >(argp2);
  (arg1)->setValue((int32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4i32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4i32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4i32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4i32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4i32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4i32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4i32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4i32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4i32::setValue(SbVec4i32 const &)\n"
    "    SoMFVec4i32::setValue(int32_t,int32_t,int32_t,int32_t)\n"
    "    SoMFVec4i32::setValue(int32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4i32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4i32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4i32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4ui32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4ui32", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4ui32 *)new SoMFVec4ui32();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4ui32, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4ui32(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4ui32" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4ui32::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4ui32::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_getTypeId" "', argument " "1"" of type '" "SoMFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  result = ((SoMFVec4ui32 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_copyFrom" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_isSame" "', argument " "1"" of type '" "SoMFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4ui32 const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_getValues" "', argument " "1"" of type '" "SoMFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4ui32 *)((SoMFVec4ui32 const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_find" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_find" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_find" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ui32_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4ui32 const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_find" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_find" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_find" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  result = (int)(arg1)->find((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ui32_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4ui32_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ui32_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ui32::find(SbVec4ui32 const &,SbBool)\n"
    "    SoMFVec4ui32::find(SbVec4ui32 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4ui32 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValues" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ui32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4ui32_setValues" "', argument " "4"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4ui32 * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4ui32 const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  SbVec4ui32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_set1Value" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ui32_set1Value" "', argument " "3"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_set1Value" "', argument " "3"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4ui32 * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4ui32 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SbVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValue" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32_setValue" "', argument " "2"" of type '" "SbVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4ui32 * >(argp2);
  (arg1)->setValue((SbVec4ui32 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SoMFVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32___eq__" "', argument " "1"" of type '" "SoMFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32___eq__" "', argument " "2"" of type '" "SoMFVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32___eq__" "', argument " "2"" of type '" "SoMFVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4ui32 * >(argp2);
  result = (SbBool)((SoMFVec4ui32 const *)arg1)->operator ==((SoMFVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  SoMFVec4ui32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32___ne__" "', argument " "1"" of type '" "SoMFVec4ui32 const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4ui32,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32___ne__" "', argument " "2"" of type '" "SoMFVec4ui32 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4ui32___ne__" "', argument " "2"" of type '" "SoMFVec4ui32 const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4ui32 * >(argp2);
  result = (SbBool)((SoMFVec4ui32 const *)arg1)->operator !=((SoMFVec4ui32 const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4ui32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_startEditing" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  result = (SbVec4ui32 *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_finishEditing" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  SbVec4ui32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "3"" of type '" "SbVec4ui32 const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4ui32 * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4ui32 const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  SbVec4ui32 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "3"" of type '" "SbVec4ui32 *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4ui32 * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  uint32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (uint32_t*)malloc(len*sizeof(uint32_t));
      convert_SoMFUInt32_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,(uint32_t const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  uint32_t *temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    int len;
    
    if (PySequence_Check(swig_obj[2])) {
      len = PySequence_Length(swig_obj[2]);
      temp3 = (uint32_t*)malloc(len*sizeof(uint32_t));
      convert_SoMFUInt32_array(swig_obj[2], len, temp3);  
      arg3 = temp3;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a sequence.");
    }
  }
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ui32_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ui32::setValuesPointer(int const,SbVec4ui32 const *)\n"
    "    SoMFVec4ui32::setValuesPointer(int const,SbVec4ui32 *)\n"
    "    SoMFVec4ui32::setValuesPointer(int const,uint32_t const *)\n"
    "    SoMFVec4ui32::setValuesPointer(int const,uint32_t *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4ui32::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  uint32_t (*arg4)[4] = (uint32_t (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValues" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ui32_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4ui32_setValues" "', argument " "4"" of type '" "uint32_t const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< uint32_t (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(uint32_t const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4ui32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4ui32_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__unsigned_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4ui32_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ui32_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ui32::setValues(int const,int const,SbVec4ui32 const *)\n"
    "    SoMFVec4ui32::setValues(int,int,uint32_t const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  uint32_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_set1Value" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ui32_set1Value" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4ui32_set1Value" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4ui32_set1Value" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4ui32_set1Value" "', argument " "6"" of type '" "uint32_t""'");
  } 
  arg6 = static_cast< uint32_t >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  int arg2 ;
  uint32_t *arg3 = (uint32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_set1Value" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4ui32_set1Value" "', argument " "3"" of type '" "uint32_t const [4]""'"); 
  } 
  arg3 = reinterpret_cast< uint32_t * >(argp3);
  (arg1)->set1Value(arg2,(uint32_t const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4ui32_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4ui32_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ui32_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ui32::set1Value(int const,SbVec4ui32 const &)\n"
    "    SoMFVec4ui32::set1Value(int,uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    SoMFVec4ui32::set1Value(int,uint32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValue" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4ui32_setValue" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4ui32_setValue" "', argument " "4"" of type '" "uint32_t""'");
  } 
  arg4 = static_cast< uint32_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4ui32_setValue" "', argument " "5"" of type '" "uint32_t""'");
  } 
  arg5 = static_cast< uint32_t >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4ui32 *arg1 = 0 ;
  uint32_t *arg2 = (uint32_t *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4ui32, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4ui32_setValue" "', argument " "1"" of type '" "SoMFVec4ui32 *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4ui32 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4ui32_setValue" "', argument " "2"" of type '" "uint32_t const [4]""'"); 
  } 
  arg2 = reinterpret_cast< uint32_t * >(argp2);
  (arg1)->setValue((uint32_t const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4ui32_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4ui32_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4ui32, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ui32_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4ui32_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4ui32, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4ui32_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4ui32_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4ui32::setValue(SbVec4ui32 const &)\n"
    "    SoMFVec4ui32::setValue(uint32_t,uint32_t,uint32_t,uint32_t)\n"
    "    SoMFVec4ui32::setValue(uint32_t const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4ui32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4ui32, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4ui32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoMFVec4d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMFVec4d", 0, 0, 0)) SWIG_fail;
  result = (SoMFVec4d *)new SoMFVec4d();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4d, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoMFVec4d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoMFVec4d" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoMFVec4d::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMFVec4d::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_getTypeId" "', argument " "1"" of type '" "SoMFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  result = ((SoMFVec4d const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_copyFrom" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_copyFrom" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  (arg1)->copyFrom((SoField const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_isSame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SoField *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_isSame", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_isSame" "', argument " "1"" of type '" "SoMFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_isSame" "', argument " "2"" of type '" "SoField const &""'"); 
  }
  arg2 = reinterpret_cast< SoField * >(argp2);
  result = (SbBool)((SoMFVec4d const *)arg1)->isSame((SoField const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_getValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_getValues" "', argument " "1"" of type '" "SoMFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_getValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec4d *)((SoMFVec4d const *)arg1)->getValues(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_find__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_find" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_find" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_find" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4d_find" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (int)(arg1)->find((SbVec4d const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_find__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_find" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_find" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_find" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  result = (int)(arg1)->find((SbVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4d_find", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4d_find__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoMFVec4d_find__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4d_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4d::find(SbVec4d const &,SbBool)\n"
    "    SoMFVec4d::find(SbVec4d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValues__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbVec4d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValues" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4d_setValues" "', argument " "4"" of type '" "SbVec4d const *""'"); 
  }
  arg4 = reinterpret_cast< SbVec4d * >(argp4);
  (arg1)->setValues(arg2,arg3,(SbVec4d const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_set1Value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  SbVec4d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_set1Value" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_set1Value" "', argument " "3"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_set1Value" "', argument " "3"" of type '" "SbVec4d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4d * >(argp3);
  (arg1)->set1Value(arg2,(SbVec4d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValue" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d_setValue" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  (arg1)->setValue((SbVec4d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SoMFVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d___eq__" "', argument " "1"" of type '" "SoMFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d___eq__" "', argument " "2"" of type '" "SoMFVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d___eq__" "', argument " "2"" of type '" "SoMFVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4d * >(argp2);
  result = (SbBool)((SoMFVec4d const *)arg1)->operator ==((SoMFVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  SoMFVec4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d___ne__" "', argument " "1"" of type '" "SoMFVec4d const *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoMFVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d___ne__" "', argument " "2"" of type '" "SoMFVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMFVec4d___ne__" "', argument " "2"" of type '" "SoMFVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4d * >(argp2);
  result = (SbBool)((SoMFVec4d const *)arg1)->operator !=((SoMFVec4d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_startEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_startEditing" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  result = (SbVec4d *)(arg1)->startEditing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_finishEditing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_finishEditing" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  (arg1)->finishEditing();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValuesPointer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  SbVec4d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "3"" of type '" "SbVec4d const *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4d * >(argp3);
  (arg1)->setValuesPointer(arg2,(SbVec4d const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValuesPointer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  SbVec4d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec4d, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "3"" of type '" "SbVec4d *""'"); 
  }
  arg3 = reinterpret_cast< SbVec4d * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValuesPointer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "3"" of type '" "double const *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,(double const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValuesPointer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_setValuesPointer" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->setValuesPointer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValuesPointer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4d_setValuesPointer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_setValuesPointer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4d, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_setValuesPointer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_setValuesPointer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_setValuesPointer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4d_setValuesPointer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4d::setValuesPointer(int const,SbVec4d const *)\n"
    "    SoMFVec4d::setValuesPointer(int const,SbVec4d *)\n"
    "    SoMFVec4d::setValuesPointer(int const,double const *)\n"
    "    SoMFVec4d::setValuesPointer(int const,double *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMFVec4d_initClass", 0, 0, 0)) SWIG_fail;
  SoMFVec4d::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValues__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  double (*arg4)[4] = (double (*)[4])0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValues" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4d_setValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_a_4__double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMFVec4d_setValues" "', argument " "4"" of type '" "double const [][4]""'"); 
  } 
  arg4 = reinterpret_cast< double (*)[4] >(argp4);
  (arg1)->setValues(arg2,arg3,(double const (*)[4])arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValues(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4d_setValues", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec4d, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4d_setValues__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_a_4__double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoMFVec4d_setValues__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4d_setValues'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4d::setValues(int const,int const,SbVec4d const *)\n"
    "    SoMFVec4d::setValues(int,int,double const [][4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_set1Value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_set1Value" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4d_set1Value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4d_set1Value" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4d_set1Value" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoMFVec4d_set1Value" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  (arg1)->set1Value(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_set1Value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  int arg2 ;
  double *arg3 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_set1Value" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_set1Value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMFVec4d_set1Value" "', argument " "3"" of type '" "double const [4]""'"); 
  } 
  arg3 = reinterpret_cast< double * >(argp3);
  (arg1)->set1Value(arg2,(double const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_set1Value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4d_set1Value", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_set1Value__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMFVec4d_set1Value__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoMFVec4d_set1Value__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4d_set1Value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4d::set1Value(int const,SbVec4d const &)\n"
    "    SoMFVec4d::set1Value(int,double,double,double,double)\n"
    "    SoMFVec4d::set1Value(int,double const [4])\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValue" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMFVec4d_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoMFVec4d_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMFVec4d_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMFVec4d_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoMFVec4d *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMFVec4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMFVec4d_setValue" "', argument " "1"" of type '" "SoMFVec4d *""'"); 
  }
  arg1 = reinterpret_cast< SoMFVec4d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMFVec4d_setValue" "', argument " "2"" of type '" "double const [4]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMFVec4d_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMFVec4d_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4d_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoMFVec4d_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoMFVec4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMFVec4d_setValue__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMFVec4d_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMFVec4d::setValue(SbVec4d const &)\n"
    "    SoMFVec4d::setValue(double,double,double,double)\n"
    "    SoMFVec4d::setValue(double const [4])\n");
  return 0;
}


SWIGINTERN PyObject *SoMFVec4d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMFVec4d, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMFVec4d_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbStringList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbStringList *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbStringList *)new SbStringList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStringList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbStringList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbStringList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbStringList" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbStringList *)new SbStringList(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStringList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbStringList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbStringList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbStringList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbStringList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbStringList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbStringList::SbStringList()\n"
    "    SbStringList::SbStringList(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbStringList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList_append" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbStringList_append" "', argument " "2"" of type '" "SbString *""'"); 
  }
  arg2 = reinterpret_cast< SbString * >(argp2);
  (arg1)->append(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList_find" "', argument " "1"" of type '" "SbStringList const *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbStringList_find" "', argument " "2"" of type '" "SbString *""'"); 
  }
  arg2 = reinterpret_cast< SbString * >(argp2);
  result = (int)((SbStringList const *)arg1)->find(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  SbString *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList_insert" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbStringList_insert" "', argument " "2"" of type '" "SbString *""'"); 
  }
  arg2 = reinterpret_cast< SbString * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbStringList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList_getArrayPtr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList_getArrayPtr" "', argument " "1"" of type '" "SbStringList const *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  result = (SbString **)((SbStringList const *)arg1)->getArrayPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  int arg2 ;
  SbString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList___setitem__" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbStringList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbStringList___setitem__" "', argument " "3"" of type '" "SbString *""'"); 
  }
  arg3 = reinterpret_cast< SbString * >(argp3);
  SbStringList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList___getitem__" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbStringList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbString *)SbStringList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStringList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStringList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStringList_get" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbStringList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbString *)SbStringList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbStringList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStringList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbStringList" "', argument " "1"" of type '" "SbStringList *""'"); 
  }
  arg1 = reinterpret_cast< SbStringList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbStringList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbStringList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbStringList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbVec3fList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbVec3fList", 0, 0, 0)) SWIG_fail;
  result = (SbVec3fList *)new SbVec3fList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3fList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbVec3fList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbVec3fList" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3fList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3fList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3fList_append" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3fList_append" "', argument " "2"" of type '" "SbVec3f const *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->append((SbVec3f const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3fList_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3fList_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3fList_insert" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbVec3fList_insert" "', argument " "2"" of type '" "SbVec3f const *""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbVec3fList_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert((SbVec3f const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3fList___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3fList___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3fList___setitem__" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3fList___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbVec3fList___setitem__" "', argument " "3"" of type '" "SbVec3f *""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SbVec3fList___setitem__(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3fList___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3fList___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3fList___getitem__" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3fList___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *)SbVec3fList___getitem__(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbVec3fList_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3fList *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbVec3fList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbVec3fList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbVec3fList_get" "', argument " "1"" of type '" "SbVec3fList *""'"); 
  }
  arg1 = reinterpret_cast< SbVec3fList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbVec3fList_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbVec3f *)SbVec3fList_get(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbVec3fList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbVec3fList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbVec3fList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLockManager_SetUnlockString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLockManager_SetUnlockString" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  SoLockManager::SetUnlockString(arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLockManager_GetUnlockString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLockManager_GetUnlockString", 0, 0, 0)) SWIG_fail;
  result = (char *)SoLockManager::GetUnlockString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLockManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLockManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLockManager", 0, 0, 0)) SWIG_fail;
  result = (SoLockManager *)new SoLockManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLockManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoLockManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLockManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLockManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoLockManager" "', argument " "1"" of type '" "SoLockManager *""'"); 
  }
  arg1 = reinterpret_cast< SoLockManager * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLockManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLockManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLockManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getTypeId" "', argument " "1"" of type '" "SoTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = ((SoTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransform", 0, 0, 0)) SWIG_fail;
  result = (SoTransform *)new SoTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_translation_set" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_translation_get" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_rotation_set" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_rotation_get" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_scaleFactor_set" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_scaleFactor_get" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_scaleOrientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_scaleOrientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_scaleOrientation_set" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_scaleOrientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->scaleOrientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_scaleOrientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_scaleOrientation_get" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->scaleOrientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_center_set" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_center_get" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_pointAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_pointAt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_pointAt" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTransform_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->pointAt((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getScaleSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getScaleSpaceMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getScaleSpaceMatrix" "', argument " "1"" of type '" "SoTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getScaleSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getScaleSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTransform_getScaleSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getScaleSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoTransform const *)arg1)->getScaleSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getRotationSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getRotationSpaceMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getRotationSpaceMatrix" "', argument " "1"" of type '" "SoTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getRotationSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getRotationSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTransform_getRotationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getRotationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoTransform const *)arg1)->getRotationSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getTranslationSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getTranslationSpaceMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getTranslationSpaceMatrix" "', argument " "1"" of type '" "SoTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getTranslationSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getTranslationSpaceMatrix" "', argument " "2"" of type '" "SbMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTransform_getTranslationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_getTranslationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoTransform const *)arg1)->getTranslationSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_multLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_multLeft", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_multLeft" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_multLeft" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_multLeft" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->multLeft((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_multRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_multRight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_multRight" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_multRight" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_multRight" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->multRight((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_combineLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoTransformation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_combineLeft", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_combineLeft" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTransformation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_combineLeft" "', argument " "2"" of type '" "SoTransformation *""'"); 
  }
  arg2 = reinterpret_cast< SoTransformation * >(argp2);
  (arg1)->combineLeft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_combineRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoTransformation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_combineRight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_combineRight" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoTransformation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_combineRight" "', argument " "2"" of type '" "SoTransformation *""'"); 
  }
  arg2 = reinterpret_cast< SoTransformation * >(argp2);
  (arg1)->combineRight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_setMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_setMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_setMatrix" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_setMatrix" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_setMatrix" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setMatrix((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_recenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_recenter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_recenter" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_recenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTransform_recenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->recenter((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_doAction" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_GLRender" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_callback" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getBoundingBox" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getMatrix" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_pick" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransform_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransform *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransform_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransform_getPrimitiveCount" "', argument " "1"" of type '" "SoTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransform_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_getTypeId" "', argument " "1"" of type '" "SoTransformManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  result = ((SoTransformManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformManip", 0, 0, 0)) SWIG_fail;
  result = (SoTransformManip *)new SoTransformManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_getDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_getDragger" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  result = (SoDragger *)(arg1)->getDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_replaceNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_replaceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_replaceNode" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_replaceNode" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->replaceNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_replaceManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoTransform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_replaceManip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_replaceManip" "', argument " "1"" of type '" "SoTransformManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_replaceManip" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoTransform, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTransformManip_replaceManip" "', argument " "3"" of type '" "SoTransform *""'"); 
  }
  arg3 = reinterpret_cast< SoTransform * >(argp3);
  result = (SbBool)((SoTransformManip const *)arg1)->replaceManip(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_doAction" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_callback" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_GLRender" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_getBoundingBox" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_getMatrix" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_handleEvent" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_pick" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformManip_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_search" "', argument " "1"" of type '" "SoTransformManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformManip_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformManip_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformManip_getChildren" "', argument " "1"" of type '" "SoTransformManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformManip * >(argp1);
  result = (SoChildList *)((SoTransformManip const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCenterballManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCenterballManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCenterballManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCenterballManip_getTypeId" "', argument " "1"" of type '" "SoCenterballManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoCenterballManip * >(argp1);
  result = ((SoCenterballManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCenterballManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCenterballManip_initClass", 0, 0, 0)) SWIG_fail;
  SoCenterballManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCenterballManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCenterballManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCenterballManip", 0, 0, 0)) SWIG_fail;
  result = (SoCenterballManip *)new SoCenterballManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCenterballManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCenterballManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCenterballManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCenterballManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoClipPlane_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoClipPlane::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_getTypeId" "', argument " "1"" of type '" "SoClipPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  result = ((SoClipPlane const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_initClass", 0, 0, 0)) SWIG_fail;
  SoClipPlane::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoClipPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoClipPlane", 0, 0, 0)) SWIG_fail;
  result = (SoClipPlane *)new SoClipPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoClipPlane, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_plane_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoSFPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_plane_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_plane_set" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_plane_set" "', argument " "2"" of type '" "SoSFPlane *""'"); 
  }
  arg2 = reinterpret_cast< SoSFPlane * >(argp2);
  if (arg1) (arg1)->plane = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_plane_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFPlane *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_plane_get" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  result = (SoSFPlane *)& ((arg1)->plane);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_on_set" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_on_get" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_doAction" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_GLRender" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_callback" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlane_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlane *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlane_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlane_pick" "', argument " "1"" of type '" "SoClipPlane *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlane_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoClipPlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoClipPlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoClipPlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoClipPlaneManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_getTypeId" "', argument " "1"" of type '" "SoClipPlaneManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  result = ((SoClipPlaneManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_initClass", 0, 0, 0)) SWIG_fail;
  SoClipPlaneManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoClipPlaneManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoClipPlaneManip", 0, 0, 0)) SWIG_fail;
  result = (SoClipPlaneManip *)new SoClipPlaneManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoClipPlaneManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_getDragger" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  result = (SoDragger *)(arg1)->getDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_setValue", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_setValue" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_setValue" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoClipPlaneManip_setValue" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoClipPlaneManip_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoClipPlaneManip_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoClipPlaneManip_setValue" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setValue((SbBox3f const &)*arg2,(SbVec3f const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_replaceNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_replaceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_replaceNode" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_replaceNode" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->replaceNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_replaceManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoClipPlane *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_replaceManip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_replaceManip" "', argument " "1"" of type '" "SoClipPlaneManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_replaceManip" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoClipPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoClipPlaneManip_replaceManip" "', argument " "3"" of type '" "SoClipPlane *""'"); 
  }
  arg3 = reinterpret_cast< SoClipPlane * >(argp3);
  result = (SbBool)((SoClipPlaneManip const *)arg1)->replaceManip(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_doAction" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_callback" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_GLRender" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_getBoundingBox" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_getMatrix" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_handleEvent" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_pick" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_search" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_getChildren" "', argument " "1"" of type '" "SoClipPlaneManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  result = (SoChildList *)((SoClipPlaneManip const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_draggerPosition_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoClipPlaneManip_draggerPosition_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_draggerPosition_set" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoClipPlaneManip_draggerPosition_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->draggerPosition = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoClipPlaneManip_draggerPosition_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoClipPlaneManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoClipPlaneManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoClipPlaneManip_draggerPosition_get" "', argument " "1"" of type '" "SoClipPlaneManip *""'"); 
  }
  arg1 = reinterpret_cast< SoClipPlaneManip * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->draggerPosition);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoClipPlaneManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoClipPlaneManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoClipPlaneManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_getTypeId" "', argument " "1"" of type '" "SoLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  result = ((SoLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_initClass", 0, 0, 0)) SWIG_fail;
  SoLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_on_set" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLight_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_on_get" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_intensity_set" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLight_intensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->intensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_intensity_get" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->intensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_color_set" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLight_color_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_color_get" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  result = (SoSFColor *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLight_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLight *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLight_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLight_callback" "', argument " "1"" of type '" "SoLight *""'"); 
  }
  arg1 = reinterpret_cast< SoLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLight_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoDirectionalLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDirectionalLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLight_getTypeId" "', argument " "1"" of type '" "SoDirectionalLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLight * >(argp1);
  result = ((SoDirectionalLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLight_initClass", 0, 0, 0)) SWIG_fail;
  SoDirectionalLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDirectionalLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDirectionalLight", 0, 0, 0)) SWIG_fail;
  result = (SoDirectionalLight *)new SoDirectionalLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDirectionalLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLight_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLight_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLight_direction_set" "', argument " "1"" of type '" "SoDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLight_direction_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLight_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLight_direction_get" "', argument " "1"" of type '" "SoDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLight_GLRender" "', argument " "1"" of type '" "SoDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDirectionalLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDirectionalLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDirectionalLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDirectionalLightManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_getTypeId" "', argument " "1"" of type '" "SoDirectionalLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  result = ((SoDirectionalLightManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_initClass", 0, 0, 0)) SWIG_fail;
  SoDirectionalLightManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDirectionalLightManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDirectionalLightManip", 0, 0, 0)) SWIG_fail;
  result = (SoDirectionalLightManip *)new SoDirectionalLightManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDirectionalLightManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_getDragger" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  result = (SoDragger *)(arg1)->getDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_replaceNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_replaceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_replaceNode" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_replaceNode" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->replaceNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_replaceManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoDirectionalLight *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_replaceManip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_replaceManip" "', argument " "1"" of type '" "SoDirectionalLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_replaceManip" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoDirectionalLightManip_replaceManip" "', argument " "3"" of type '" "SoDirectionalLight *""'"); 
  }
  arg3 = reinterpret_cast< SoDirectionalLight * >(argp3);
  result = (SbBool)((SoDirectionalLightManip const *)arg1)->replaceManip(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_doAction" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_callback" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_GLRender" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_getBoundingBox" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_getMatrix" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_handleEvent" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_pick" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDirectionalLightManip_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_search" "', argument " "1"" of type '" "SoDirectionalLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDirectionalLightManip_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDirectionalLightManip_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDirectionalLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDirectionalLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDirectionalLightManip_getChildren" "', argument " "1"" of type '" "SoDirectionalLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoDirectionalLightManip * >(argp1);
  result = (SoChildList *)((SoDirectionalLightManip const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDirectionalLightManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDirectionalLightManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDirectionalLightManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoHandleBoxManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoHandleBoxManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoHandleBoxManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoHandleBoxManip_getTypeId" "', argument " "1"" of type '" "SoHandleBoxManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoHandleBoxManip * >(argp1);
  result = ((SoHandleBoxManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoHandleBoxManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoHandleBoxManip_initClass", 0, 0, 0)) SWIG_fail;
  SoHandleBoxManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoHandleBoxManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoHandleBoxManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoHandleBoxManip", 0, 0, 0)) SWIG_fail;
  result = (SoHandleBoxManip *)new SoHandleBoxManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleBoxManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoHandleBoxManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoHandleBoxManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoHandleBoxManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoJackManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoJackManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoJackManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoJackManip_getTypeId" "', argument " "1"" of type '" "SoJackManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoJackManip * >(argp1);
  result = ((SoJackManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoJackManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoJackManip_initClass", 0, 0, 0)) SWIG_fail;
  SoJackManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoJackManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoJackManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoJackManip", 0, 0, 0)) SWIG_fail;
  result = (SoJackManip *)new SoJackManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoJackManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoJackManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoJackManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoJackManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPointLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLight_getTypeId" "', argument " "1"" of type '" "SoPointLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLight * >(argp1);
  result = ((SoPointLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLight_initClass", 0, 0, 0)) SWIG_fail;
  SoPointLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPointLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPointLight", 0, 0, 0)) SWIG_fail;
  result = (SoPointLight *)new SoPointLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLight_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLight_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLight_location_set" "', argument " "1"" of type '" "SoPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLight_location_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLight_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLight_location_get" "', argument " "1"" of type '" "SoPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLight_GLRender" "', argument " "1"" of type '" "SoPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPointLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPointLightManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointLightManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_getTypeId" "', argument " "1"" of type '" "SoPointLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  result = ((SoPointLightManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_initClass", 0, 0, 0)) SWIG_fail;
  SoPointLightManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPointLightManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPointLightManip", 0, 0, 0)) SWIG_fail;
  result = (SoPointLightManip *)new SoPointLightManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointLightManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_getDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_getDragger" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  result = (SoDragger *)(arg1)->getDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_replaceNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_replaceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_replaceNode" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_replaceNode" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->replaceNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_replaceManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoPointLight *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_replaceManip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_replaceManip" "', argument " "1"" of type '" "SoPointLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_replaceManip" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPointLight, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPointLightManip_replaceManip" "', argument " "3"" of type '" "SoPointLight *""'"); 
  }
  arg3 = reinterpret_cast< SoPointLight * >(argp3);
  result = (SbBool)((SoPointLightManip const *)arg1)->replaceManip(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_doAction" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_callback" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_GLRender" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_getBoundingBox" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_getMatrix" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_handleEvent" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_pick" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointLightManip_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_search" "', argument " "1"" of type '" "SoPointLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointLightManip_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointLightManip_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointLightManip_getChildren" "', argument " "1"" of type '" "SoPointLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointLightManip * >(argp1);
  result = (SoChildList *)((SoPointLightManip const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointLightManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointLightManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPointLightManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSpotLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSpotLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_getTypeId" "', argument " "1"" of type '" "SoSpotLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  result = ((SoSpotLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_initClass", 0, 0, 0)) SWIG_fail;
  SoSpotLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSpotLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSpotLight", 0, 0, 0)) SWIG_fail;
  result = (SoSpotLight *)new SoSpotLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSpotLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_location_set" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLight_location_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_location_get" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_direction_set" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLight_direction_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_direction_get" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_dropOffRate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_dropOffRate_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_dropOffRate_set" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLight_dropOffRate_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->dropOffRate = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_dropOffRate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_dropOffRate_get" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->dropOffRate);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_cutOffAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_cutOffAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_cutOffAngle_set" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLight_cutOffAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->cutOffAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_cutOffAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_cutOffAngle_get" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->cutOffAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLight_GLRender" "', argument " "1"" of type '" "SoSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSpotLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSpotLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSpotLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSpotLightManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSpotLightManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_getTypeId" "', argument " "1"" of type '" "SoSpotLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  result = ((SoSpotLightManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_initClass", 0, 0, 0)) SWIG_fail;
  SoSpotLightManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSpotLightManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSpotLightManip", 0, 0, 0)) SWIG_fail;
  result = (SoSpotLightManip *)new SoSpotLightManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSpotLightManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_getDragger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDragger *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_getDragger" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  result = (SoDragger *)(arg1)->getDragger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDragger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_replaceNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_replaceNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_replaceNode" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_replaceNode" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->replaceNode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_replaceManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SoSpotLight *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_replaceManip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_replaceManip" "', argument " "1"" of type '" "SoSpotLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_replaceManip" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSpotLightManip_replaceManip" "', argument " "3"" of type '" "SoSpotLight *""'"); 
  }
  arg3 = reinterpret_cast< SoSpotLight * >(argp3);
  result = (SbBool)((SoSpotLightManip const *)arg1)->replaceManip(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_doAction" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_callback" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_GLRender" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_getBoundingBox" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_getMatrix" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_handleEvent" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_pick" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSpotLightManip_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_search" "', argument " "1"" of type '" "SoSpotLightManip *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSpotLightManip_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSpotLightManip_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSpotLightManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSpotLightManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSpotLightManip_getChildren" "', argument " "1"" of type '" "SoSpotLightManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoSpotLightManip * >(argp1);
  result = (SoChildList *)((SoSpotLightManip const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSpotLightManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSpotLightManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSpotLightManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTabBoxManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTabBoxManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTabBoxManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTabBoxManip_getTypeId" "', argument " "1"" of type '" "SoTabBoxManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTabBoxManip * >(argp1);
  result = ((SoTabBoxManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTabBoxManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTabBoxManip_initClass", 0, 0, 0)) SWIG_fail;
  SoTabBoxManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTabBoxManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTabBoxManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTabBoxManip", 0, 0, 0)) SWIG_fail;
  result = (SoTabBoxManip *)new SoTabBoxManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTabBoxManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTabBoxManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTabBoxManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTabBoxManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTrackballManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTrackballManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTrackballManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTrackballManip_getTypeId" "', argument " "1"" of type '" "SoTrackballManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTrackballManip * >(argp1);
  result = ((SoTrackballManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTrackballManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTrackballManip_initClass", 0, 0, 0)) SWIG_fail;
  SoTrackballManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTrackballManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTrackballManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTrackballManip", 0, 0, 0)) SWIG_fail;
  result = (SoTrackballManip *)new SoTrackballManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTrackballManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTrackballManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTrackballManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTrackballManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformBoxManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformBoxManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformBoxManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformBoxManip_getTypeId" "', argument " "1"" of type '" "SoTransformBoxManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformBoxManip * >(argp1);
  result = ((SoTransformBoxManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformBoxManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformBoxManip_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformBoxManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformBoxManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformBoxManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformBoxManip", 0, 0, 0)) SWIG_fail;
  result = (SoTransformBoxManip *)new SoTransformBoxManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformBoxManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformBoxManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformBoxManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformBoxManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformerManip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerManip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformerManip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerManip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerManip_getTypeId" "', argument " "1"" of type '" "SoTransformerManip const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerManip * >(argp1);
  result = ((SoTransformerManip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerManip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerManip_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformerManip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformerManip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerManip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransformerManip", 0, 0, 0)) SWIG_fail;
  result = (SoTransformerManip *)new SoTransformerManip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformerManip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerManip_isLocateHighlighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerManip_isLocateHighlighting" "', argument " "1"" of type '" "SoTransformerManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerManip * >(argp1);
  result = (SbBool)(arg1)->isLocateHighlighting();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerManip_setLocateHighlighting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerManip *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformerManip_setLocateHighlighting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerManip_setLocateHighlighting" "', argument " "1"" of type '" "SoTransformerManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerManip * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoTransformerManip_setLocateHighlighting" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setLocateHighlighting(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformerManip_unsquishKnobs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformerManip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformerManip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformerManip_unsquishKnobs" "', argument " "1"" of type '" "SoTransformerManip *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformerManip * >(argp1);
  (arg1)->unsquishKnobs();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformerManip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformerManip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformerManip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAudioDevice_instance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioDevice_instance", 0, 0, 0)) SWIG_fail;
  result = (SoAudioDevice *)SoAudioDevice::instance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioDevice_init", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_init" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))  
    {
      arg3 = new SbString(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg3 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)(arg1)->init((SbString const &)*arg2,(SbString const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_enable" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  result = (SbBool)(arg1)->enable();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_disable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_disable" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  (arg1)->disable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_isEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_isEnabled" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  result = (SbBool)(arg1)->isEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_haveSound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_haveSound" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  result = (SbBool)(arg1)->haveSound();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_setGain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAudioDevice_setGain", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_setGain" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAudioDevice_setGain" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setGain(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_mute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_mute" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoAudioDevice_mute" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->mute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_mute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoAudioDevice *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAudioDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAudioDevice_mute" "', argument " "1"" of type '" "SoAudioDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoAudioDevice * >(argp1);
  (arg1)->mute();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAudioDevice_mute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoAudioDevice_mute", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAudioDevice, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoAudioDevice_mute__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoAudioDevice, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoAudioDevice_mute__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoAudioDevice_mute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoAudioDevice::mute(SbBool)\n"
    "    SoAudioDevice::mute()\n");
  return 0;
}


SWIGINTERN PyObject *SoAudioDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAudioDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SoByteStream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoByteStream", 0, 0, 0)) SWIG_fail;
  result = (SoByteStream *)new SoByteStream();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoByteStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoByteStream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoByteStream" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoByteStream_convert" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->convert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->convert(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoByteStream_convert" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->convert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->convert(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoPathList *""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoByteStream_convert" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->convert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  SoPathList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_convert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPathList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_convert" "', argument " "2"" of type '" "SoPathList *""'"); 
  }
  arg2 = reinterpret_cast< SoPathList * >(argp2);
  (arg1)->convert(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_convert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoByteStream_convert", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoByteStream_convert__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoByteStream_convert__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPathList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoByteStream_convert__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoByteStream_convert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPathList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoByteStream_convert__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoByteStream_convert__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoByteStream_convert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoByteStream::convert(SoNode *,SbBool)\n"
    "    SoByteStream::convert(SoNode *)\n"
    "    SoByteStream::convert(SoPath *,SbBool)\n"
    "    SoByteStream::convert(SoPath *)\n"
    "    SoByteStream::convert(SoPathList *,SbBool)\n"
    "    SoByteStream::convert(SoPathList *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoByteStream_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_getData" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  result = (void *)(arg1)->getData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_getNumBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_getNumBytes" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  result = (uint32_t)(arg1)->getNumBytes();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_unconvert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPathList *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_unconvert" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  result = (SoPathList *)SoByteStream::unconvert(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_unconvert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  void *arg1 = 0 ;
  uint32_t arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SoPathList *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (!PyTuple_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[0]);
    arg1 = (void *)swig_obj[0];
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoByteStream_unconvert" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  result = (SoPathList *)SoByteStream::unconvert(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_unconvert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoByteStream_unconvert", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoByteStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoByteStream_unconvert__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      _v = PyTuple_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoByteStream_unconvert__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoByteStream_unconvert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoByteStream::unconvert(SoByteStream *)\n"
    "    SoByteStream::unconvert(void *,uint32_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoByteStream_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoByteStream_copy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_copy" "', argument " "1"" of type '" "SoByteStream *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoByteStream_copy" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoByteStream_copy" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->copy(arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoByteStream_isRawData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoByteStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoByteStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoByteStream_isRawData" "', argument " "1"" of type '" "SoByteStream const *""'"); 
  }
  arg1 = reinterpret_cast< SoByteStream * >(argp1);
  result = (SbBool)((SoByteStream const *)arg1)->isRawData();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoByteStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoByteStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoByteStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoContextHandler_destructingContext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoContextHandler_destructingContext" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  SoContextHandler::destructingContext(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoContextHandler_addContextDestructionCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoContextHandler::ContextDestructionCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoContextHandler_addContextDestructionCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_unsigned_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoContextHandler_addContextDestructionCallback" "', argument " "1"" of type '" "SoContextHandler::ContextDestructionCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoContextHandler_addContextDestructionCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoContextHandler::addContextDestructionCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoContextHandler_removeContextDestructionCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoContextHandler::ContextDestructionCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoContextHandler_removeContextDestructionCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_unsigned_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoContextHandler_removeContextDestructionCallback" "', argument " "1"" of type '" "SoContextHandler::ContextDestructionCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoContextHandler_removeContextDestructionCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoContextHandler::removeContextDestructionCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoContextHandler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoContextHandler *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoContextHandler", 0, 0, 0)) SWIG_fail;
  result = (SoContextHandler *)new SoContextHandler();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoContextHandler, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoContextHandler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoContextHandler *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoContextHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoContextHandler" "', argument " "1"" of type '" "SoContextHandler *""'"); 
  }
  arg1 = reinterpret_cast< SoContextHandler * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoContextHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoContextHandler, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoContextHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoGLImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGLImage", 0, 0, 0)) SWIG_fail;
  result = (SoGLImage *)new SoGLImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_unref__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_unref" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_unref" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->unref(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_unref__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_unref" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  (arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_unref(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLImage_unref", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLImage_unref__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLImage_unref__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLImage_unref'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLImage::unref(SoState *)\n"
    "    SoGLImage::unref()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLImage::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getTypeId" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = ((SoGLImage const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_isOfType" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_isOfType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_isOfType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((SoGLImage const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setGLDisplayList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoGLDisplayList *arg2 = 0 ;
  SoState *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setGLDisplayList" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList *""'"); 
  }
  arg2 = reinterpret_cast< SoGLDisplayList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setGLDisplayList" "', argument " "3"" of type '" "SoState *""'"); 
  }
  arg3 = reinterpret_cast< SoState * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setGLDisplayList" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setGLDisplayList" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setGLDisplayList" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->setGLDisplayList(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setGLDisplayList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoGLDisplayList *arg2 = 0 ;
  SoState *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setGLDisplayList" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList *""'"); 
  }
  arg2 = reinterpret_cast< SoGLDisplayList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setGLDisplayList" "', argument " "3"" of type '" "SoState *""'"); 
  }
  arg3 = reinterpret_cast< SoState * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setGLDisplayList" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setGLDisplayList" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setGLDisplayList(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setGLDisplayList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoGLDisplayList *arg2 = 0 ;
  SoState *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setGLDisplayList" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList *""'"); 
  }
  arg2 = reinterpret_cast< SoGLDisplayList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setGLDisplayList" "', argument " "3"" of type '" "SoState *""'"); 
  }
  arg3 = reinterpret_cast< SoState * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setGLDisplayList" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  (arg1)->setGLDisplayList(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setGLDisplayList__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoGLDisplayList *arg2 = 0 ;
  SoState *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setGLDisplayList" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setGLDisplayList" "', argument " "2"" of type '" "SoGLDisplayList *""'"); 
  }
  arg2 = reinterpret_cast< SoGLDisplayList * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setGLDisplayList" "', argument " "3"" of type '" "SoState *""'"); 
  }
  arg3 = reinterpret_cast< SoState * >(argp3);
  (arg1)->setGLDisplayList(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setGLDisplayList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLImage_setGLDisplayList", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoState, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLImage_setGLDisplayList__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoState, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLImage_setGLDisplayList__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoState, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setGLDisplayList__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLDisplayList, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoState, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setGLDisplayList__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLImage_setGLDisplayList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLImage::setGLDisplayList(SoGLDisplayList *,SoState *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setGLDisplayList(SoGLDisplayList *,SoState *,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setGLDisplayList(SoGLDisplayList *,SoState *,SoGLImage::Wrap const)\n"
    "    SoGLImage::setGLDisplayList(SoGLDisplayList *,SoState *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setPBuffer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setPBuffer" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setPBuffer" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setPBuffer" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setPBuffer" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setPBuffer" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setPBuffer" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->setPBuffer(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setPBuffer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setPBuffer" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setPBuffer" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setPBuffer" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setPBuffer" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setPBuffer" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setPBuffer(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setPBuffer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *arg3 = 0 ;
  SoGLImage::Wrap arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setPBuffer" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setPBuffer" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setPBuffer" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setPBuffer" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  (arg1)->setPBuffer(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setPBuffer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setPBuffer" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setPBuffer" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setPBuffer" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setPBuffer(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setPBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLImage_setPBuffer", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGLImage_setPBuffer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLImage_setPBuffer__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setPBuffer__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setPBuffer__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLImage_setPBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLImage::setPBuffer(SoState *,void *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setPBuffer(SoState *,void *,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setPBuffer(SoState *,void *,SoGLImage::Wrap const)\n"
    "    SoGLImage::setPBuffer(SoState *,void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  float arg7 ;
  int arg8 ;
  SoState *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SoGLImage_setData" "', argument " "9"" of type '" "SoState *""'"); 
  }
  arg9 = reinterpret_cast< SoState * >(argp9);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  float arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_float(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "float""'");
  } 
  arg7 = static_cast< float >(val7);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->setData((unsigned char const *)arg2,(SbVec2s const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  SoGLImage::Wrap arg7 ;
  float arg8 ;
  int arg9 ;
  SoState *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "SoGLImage::Wrap""'");
  } 
  arg7 = static_cast< SoGLImage::Wrap >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoGLImage_setData" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SoGLImage_setData" "', argument " "10"" of type '" "SoState *""'"); 
  }
  arg10 = reinterpret_cast< SoState * >(argp10);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  SoGLImage::Wrap arg7 ;
  float arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "SoGLImage::Wrap""'");
  } 
  arg7 = static_cast< SoGLImage::Wrap >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SoGLImage_setData" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  SoGLImage::Wrap arg7 ;
  float arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "SoGLImage::Wrap""'");
  } 
  arg7 = static_cast< SoGLImage::Wrap >(val7);
  ecode8 = SWIG_AsVal_float(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "float""'");
  } 
  arg8 = static_cast< float >(val8);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  SoGLImage::Wrap arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "SoGLImage::Wrap""'");
  } 
  arg7 = static_cast< SoGLImage::Wrap >(val7);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  SoGLImage::Wrap arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "SoGLImage::Wrap""'");
  } 
  arg6 = static_cast< SoGLImage::Wrap >(val6);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  unsigned char *arg2 = 0 ;
  SbVec3s *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SbVec3s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->setData((unsigned char const *)arg2,(SbVec3s const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  int arg6 ;
  SoState *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "SoState *""'"); 
  }
  arg7 = reinterpret_cast< SoState * >(argp7);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  (arg1)->setData((SbImage const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  (arg1)->setData((SbImage const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  int arg7 ;
  SoState *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoGLImage_setData" "', argument " "8"" of type '" "SoState *""'"); 
  }
  arg8 = reinterpret_cast< SoState * >(argp8);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLImage_setData" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setData" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLImage_setData", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLImage_setData__SWIG_18(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLImage_setData__SWIG_17(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLImage_setData__SWIG_16(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLImage_setData__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLImage_setData__SWIG_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setData__SWIG_11(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setData__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setData__SWIG_22(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLImage_setData__SWIG_15(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setData__SWIG_21(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setData__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setData__SWIG_14(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLImage_setData__SWIG_10(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoGLImage_setData__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoGLImage_setData__SWIG_20(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SoState, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoGLImage_setData__SWIG_13(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoGLImage_setData__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SoGLImage_setData__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SoGLImage_setData__SWIG_8(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SoState, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SoGLImage_setData__SWIG_19(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SoGLImage_setData__SWIG_7(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_SoState, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_SoGLImage_setData__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_SoState, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SoGLImage_setData__SWIG_6(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLImage_setData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec2s const &,int const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(unsigned char const *,SbVec3s const &,int const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const)\n"
    "    SoGLImage::setData(SbImage const *)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_setFlags", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setFlags" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLImage_setFlags" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setFlags(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getFlags(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getFlags" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (uint32_t)((SoGLImage const *)arg1)->getFlags();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getImage" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SbImage *)((SoGLImage const *)arg1)->getImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getGLDisplayList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoGLDisplayList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_getGLDisplayList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getGLDisplayList" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_getGLDisplayList" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (SoGLDisplayList *)(arg1)->getGLDisplayList(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_hasTransparency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_hasTransparency" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SbBool)((SoGLImage const *)arg1)->hasTransparency();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_useAlphaTest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_useAlphaTest" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SbBool)((SoGLImage const *)arg1)->useAlphaTest();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getWrapS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLImage::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getWrapS" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SoGLImage::Wrap)((SoGLImage const *)arg1)->getWrapS();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getWrapT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLImage::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getWrapT" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SoGLImage::Wrap)((SoGLImage const *)arg1)->getWrapT();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getWrapR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLImage::Wrap result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getWrapR" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (SoGLImage::Wrap)((SoGLImage const *)arg1)->getWrapR();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getQuality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getQuality" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (float)((SoGLImage const *)arg1)->getQuality();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getGLImageId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getGLImageId" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (uint32_t)((SoGLImage const *)arg1)->getGLImageId();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_beginFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_beginFrame" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLImage::beginFrame(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_tagImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoGLImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_tagImage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_tagImage" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_tagImage" "', argument " "2"" of type '" "SoGLImage *""'"); 
  }
  arg2 = reinterpret_cast< SoGLImage * >(argp2);
  SoGLImage::tagImage(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_endFrame(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_endFrame" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLImage::endFrame(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setDisplayListMaxAge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoGLImage_setDisplayListMaxAge" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  SoGLImage::setDisplayListMaxAge(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_freeAllImages__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_freeAllImages" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  SoGLImage::freeAllImages(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_freeAllImages__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  SoGLImage::freeAllImages();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_freeAllImages(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLImage_freeAllImages", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_SoGLImage_freeAllImages__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLImage_freeAllImages__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLImage_freeAllImages'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLImage::freeAllImages(SoState *)\n"
    "    SoGLImage::freeAllImages()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setEndFrameCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void (*arg2)(void *) = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_setEndFrameCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_setEndFrameCallback" "', argument " "1"" of type '" "SoGLImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLImage_setEndFrameCallback" "', argument " "2"" of type '" "void (*)(void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLImage_setEndFrameCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setEndFrameCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_getNumFramesSinceUsed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLImage_getNumFramesSinceUsed" "', argument " "1"" of type '" "SoGLImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLImage * >(argp1);
  result = (int)((SoGLImage const *)arg1)->getNumFramesSinceUsed();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_initClass", 0, 0, 0)) SWIG_fail;
  SoGLImage::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLImage_setResizeCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLImage::SoGLImageResizeCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLImage_setResizeCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoGLImage_setResizeCallback" "', argument " "1"" of type '" "SoGLImage::SoGLImageResizeCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLImage_setResizeCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoGLImage::setResizeCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLImage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGLImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoGLBigImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGLBigImage", 0, 0, 0)) SWIG_fail;
  result = (SoGLBigImage *)new SoGLBigImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLBigImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_unref__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_unref" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_unref" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->unref(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_unref__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_unref" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  (arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_unref(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLBigImage_unref", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoGLBigImage_unref__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLBigImage_unref__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLBigImage_unref'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLBigImage::unref(SoState *)\n"
    "    SoGLBigImage::unref()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGLBigImage::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_getTypeId" "', argument " "1"" of type '" "SoGLBigImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  result = ((SoGLBigImage const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  int arg6 ;
  SoState *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLBigImage_setData" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoGLBigImage_setData" "', argument " "7"" of type '" "SoState *""'"); 
  }
  arg7 = reinterpret_cast< SoState * >(argp7);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLBigImage_setData" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  (arg1)->setData((SbImage const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  (arg1)->setData((SbImage const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  int arg7 ;
  SoState *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLBigImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLBigImage_setData" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SoGLBigImage_setData" "', argument " "8"" of type '" "SoState *""'"); 
  }
  arg8 = reinterpret_cast< SoState * >(argp8);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLBigImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SoGLBigImage_setData" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  ecode6 = SWIG_AsVal_float(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoGLBigImage_setData" "', argument " "6"" of type '" "float""'");
  } 
  arg6 = static_cast< float >(val6);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  SoGLImage::Wrap arg3 ;
  SoGLImage::Wrap arg4 ;
  SoGLImage::Wrap arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_setData" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_setData" "', argument " "2"" of type '" "SbImage const *""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_setData" "', argument " "3"" of type '" "SoGLImage::Wrap""'");
  } 
  arg3 = static_cast< SoGLImage::Wrap >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_setData" "', argument " "4"" of type '" "SoGLImage::Wrap""'");
  } 
  arg4 = static_cast< SoGLImage::Wrap >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGLBigImage_setData" "', argument " "5"" of type '" "SoGLImage::Wrap""'");
  } 
  arg5 = static_cast< SoGLImage::Wrap >(val5);
  (arg1)->setData((SbImage const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGLBigImage_setData", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGLBigImage_setData__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGLBigImage_setData__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGLBigImage_setData__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLBigImage_setData__SWIG_9(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoGLBigImage_setData__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLBigImage_setData__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoGLBigImage_setData__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SoGLBigImage_setData__SWIG_7(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SoState, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SoGLBigImage_setData__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLBigImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbImage, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_SoState, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SoGLBigImage_setData__SWIG_6(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGLBigImage_setData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const)\n"
    "    SoGLBigImage::setData(SbImage const *)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const,SoState *)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const,int const)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const,float const)\n"
    "    SoGLBigImage::setData(SbImage const *,SoGLImage::Wrap const,SoGLImage::Wrap const,SoGLImage::Wrap const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_initSubImages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_initSubImages", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_initSubImages" "', argument " "1"" of type '" "SoGLBigImage const *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_initSubImages" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLBigImage_initSubImages" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  result = (int)((SoGLBigImage const *)arg1)->initSubImages((SbVec2s const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_handleSubImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  int arg2 ;
  SbVec2f *arg3 = 0 ;
  SbVec2f *arg4 = 0 ;
  SbVec2f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_handleSubImage", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_handleSubImage" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGLBigImage_handleSubImage" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGLBigImage_handleSubImage" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLBigImage_handleSubImage" "', argument " "3"" of type '" "SbVec2f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGLBigImage_handleSubImage" "', argument " "4"" of type '" "SbVec2f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLBigImage_handleSubImage" "', argument " "4"" of type '" "SbVec2f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLBigImage_handleSubImage" "', argument " "5"" of type '" "SbVec2f &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLBigImage_handleSubImage" "', argument " "5"" of type '" "SbVec2f &""'"); 
  }
  arg5 = reinterpret_cast< SbVec2f * >(argp5);
  (arg1)->handleSubImage(arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_applySubImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int arg3 ;
  float arg4 ;
  SbVec2s *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_applySubImage", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_applySubImage" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_applySubImage" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGLBigImage_applySubImage" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGLBigImage_applySubImage" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoGLBigImage_applySubImage" "', argument " "5"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGLBigImage_applySubImage" "', argument " "5"" of type '" "SbVec2s const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec2s * >(argp5);
  (arg1)->applySubImage(arg2,arg3,arg4,(SbVec2s const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_exceededChangeLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_exceededChangeLimit" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  result = (SbBool)(arg1)->exceededChangeLimit();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_setChangeLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoGLBigImage_setChangeLimit" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)SoGLBigImage::setChangeLimit(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_getGLDisplayList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLBigImage *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoGLDisplayList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_getGLDisplayList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLBigImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGLBigImage_getGLDisplayList" "', argument " "1"" of type '" "SoGLBigImage *""'"); 
  }
  arg1 = reinterpret_cast< SoGLBigImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGLBigImage_getGLDisplayList" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  result = (SoGLDisplayList *)(arg1)->getGLDisplayList(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLDisplayList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGLBigImage_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGLBigImage_initClass", 0, 0, 0)) SWIG_fail;
  SoGLBigImage::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGLBigImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGLBigImage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGLBigImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGlyph_unref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_unref" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  ((SoGlyph const *)arg1)->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getGlyph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  SbName *arg2 = 0 ;
  char val1 ;
  int ecode1 = 0 ;
  SoGlyph *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoGlyph_getGlyph" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoGlyph *)SoGlyph::getGlyph(arg1,(SbName const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGlyph, 0 |  0 );
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getCoords" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = (SbVec2f *)((SoGlyph const *)arg1)->getCoords();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getFaceIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getFaceIndices" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = (int *)((SoGlyph const *)arg1)->getFaceIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getEdgeIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getEdgeIndices" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = (int *)((SoGlyph const *)arg1)->getEdgeIndices();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getNextCWEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGlyph_getNextCWEdge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getNextCWEdge" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGlyph_getNextCWEdge" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int *)((SoGlyph const *)arg1)->getNextCWEdge(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getNextCCWEdge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGlyph_getNextCCWEdge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getNextCCWEdge" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGlyph_getNextCCWEdge" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int *)((SoGlyph const *)arg1)->getNextCCWEdge(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getWidth" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = (float)((SoGlyph const *)arg1)->getWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getBoundingBox" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = (SbBox2f *) &((SoGlyph const *)arg1)->getBoundingBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getGlyph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  unsigned int arg2 ;
  SbVec2s *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SoGlyph *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getGlyph" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGlyph_getGlyph" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGlyph_getGlyph" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGlyph_getGlyph" "', argument " "3"" of type '" "SbVec2s const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGlyph_getGlyph" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (SoGlyph *)SoGlyph::getGlyph(arg1,arg2,(SbVec2s const &)*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGlyph, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getGlyph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGlyph_getGlyph", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SoGlyph_getGlyph__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoGlyph_getGlyph__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGlyph_getGlyph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGlyph::getGlyph(char const,SbName const &)\n"
    "    SoGlyph::getGlyph(SoState *,unsigned int const,SbVec2s const &,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getAdvance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getAdvance" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  result = ((SoGlyph const *)arg1)->getAdvance();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getKerning(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  SoGlyph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGlyph_getKerning", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getKerning" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoGlyph,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGlyph_getKerning" "', argument " "2"" of type '" "SoGlyph const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGlyph_getKerning" "', argument " "2"" of type '" "SoGlyph const &""'"); 
  }
  arg2 = reinterpret_cast< SoGlyph * >(argp2);
  result = ((SoGlyph const *)arg1)->getKerning((SoGlyph const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGlyph_getBitmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGlyph *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  SbVec2s *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  unsigned char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGlyph_getBitmap", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGlyph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGlyph_getBitmap" "', argument " "1"" of type '" "SoGlyph const *""'"); 
  }
  arg1 = reinterpret_cast< SoGlyph * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGlyph_getBitmap" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGlyph_getBitmap" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGlyph_getBitmap" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGlyph_getBitmap" "', argument " "3"" of type '" "SbVec2s &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2s * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoGlyph_getBitmap" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (unsigned char *)((SoGlyph const *)arg1)->getBitmap(*arg2,*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGlyph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGlyph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbDPMatrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDPMatrix *)new SbDPMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPMatrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbDPMatrix" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbDPMatrix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbDPMatrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbDPMatrix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SbDPMatrix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SbDPMatrix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SbDPMatrix" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SbDPMatrix" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SbDPMatrix" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SbDPMatrix" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SbDPMatrix" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SbDPMatrix" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SbDPMatrix" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SbDPMatrix" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SbDPMatrix" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SbDPMatrix" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (SbDPMatrix *)new SbDPMatrix(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPMatrix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMat *arg1 = 0 ;
  SbDPMat temp1 ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbDPMat_array(swig_obj[0], temp1);
    arg1 = &temp1;
  }
  result = (SbDPMatrix *)new SbDPMatrix((SbDPMat const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPMatrix__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMat *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_a_4__a_4__double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPMatrix" "', argument " "1"" of type '" "SbDPMat const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMat * >(argp1);
  result = (SbDPMatrix *)new SbDPMatrix((SbDPMat const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPMatrix__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbMatrix *arg1 = 0 ;
  SbDPMatrix *result = 0 ;
  
  {
    arg1 = new SbMatrix();
  }
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDPMatrix *)new SbDPMatrix((SbMatrix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NEW |  0 );
  {
    resultobj = SWIG_NewPointerObj((void *) arg1, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[17] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbDPMatrix", 0, 16, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbDPMatrix__SWIG_0(self, argc, argv);
  }
  if (argc == 0) {
    return _wrap_new_SbDPMatrix__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_4__a_4__double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbDPMatrix__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbDPMatrix__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SbDPMatrix__SWIG_1(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbDPMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::SbDPMatrix()\n"
    "    SbDPMatrix::SbDPMatrix(double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const,double const)\n"
    "    SbDPMatrix::SbDPMatrix(SbDPMat const &)\n"
    "    SbDPMatrix::SbDPMatrix(SbDPMat const *)\n"
    "    SbDPMatrix::SbDPMatrix(SbMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbDPMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDPMatrix" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPMat temp2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setValue" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  {
    convert_SbDPMat_array(swig_obj[1], temp2);
    arg2 = &temp2;
  }
  (arg1)->setValue((SbDPMat const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setValue" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setValue" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setValue((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setValue" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setValue" "', argument " "2"" of type '" "double const *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  (arg1)->setValue((double const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPMatrix_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPMatrix_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbDPMatrix_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::setValue(SbDPMat const &)\n"
    "    SbDPMatrix::setValue(SbMatrix const &)\n"
    "    SbDPMatrix::setValue(double const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPMat *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_getValue" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = (SbDPMat *) &((SbDPMatrix const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("((ffff)(ffff)(ffff)(ffff))",
      (double)(*result)[0][0],
      (double)(*result)[0][1],
      (double)(*result)[0][2],
      (double)(*result)[0][3],
      
      (double)(*result)[1][0],
      (double)(*result)[1][1],
      (double)(*result)[1][2],
      (double)(*result)[1][3],
      
      (double)(*result)[2][0],
      (double)(*result)[2][1],
      (double)(*result)[2][2],
      (double)(*result)[2][3],
      
      (double)(*result)[3][0],
      (double)(*result)[3][1],
      (double)(*result)[3][2],
      (double)(*result)[3][3]);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_makeIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_makeIdentity" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  (arg1)->makeIdentity();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setRotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_setRotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setRotate" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setRotate" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setRotate" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  (arg1)->setRotate((SbDPRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_inverse" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = ((SbDPMatrix const *)arg1)->inverse();
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_det3__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_det3" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPMatrix_det3" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPMatrix_det3" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPMatrix_det3" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPMatrix_det3" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbDPMatrix_det3" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SbDPMatrix_det3" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)((SbDPMatrix const *)arg1)->det3(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_det3__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_det3" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = (double)((SbDPMatrix const *)arg1)->det3();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_det3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_det3", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbDPMatrix_det3__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SbDPMatrix_det3__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_det3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::det3(int,int,int,int,int,int) const\n"
    "    SbDPMatrix::det3() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_det4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_det4" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = (double)((SbDPMatrix const *)arg1)->det4();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_equals" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_equals" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_equals" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPMatrix_equals" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbBool)((SbDPMatrix const *)arg1)->equals((SbDPMatrix const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPMat temp2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_getValue" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  {
    convert_SbDPMat_array(swig_obj[1], temp2);
    arg2 = &temp2;
  }
  ((SbDPMatrix const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_getValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbDPMatrix_getValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbDPMatrix_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::getValue() const\n"
    "    SbDPMatrix::getValue(SbDPMat &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_identity", 0, 0, 0)) SWIG_fail;
  result = SbDPMatrix::identity();
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setScale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setScale" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPMatrix_setScale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setScale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setScale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setScale" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setScale" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setScale" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->setScale((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setScale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_setScale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPMatrix_setScale__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbDPMatrix_setScale__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_setScale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::setScale(double const)\n"
    "    SbDPMatrix::setScale(SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setTranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_setTranslate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setTranslate" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setTranslate" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTranslate" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  (arg1)->setTranslate((SbVec3d const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setTransform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbDPRotation *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setTransform" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbDPRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  (arg1)->setTransform((SbVec3d const &)*arg2,(SbDPRotation const &)*arg3,(SbVec3d const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setTransform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbDPRotation *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  SbDPRotation *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setTransform" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbDPRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbDPMatrix_setTransform" "', argument " "5"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "5"" of type '" "SbDPRotation const &""'"); 
  }
  arg5 = reinterpret_cast< SbDPRotation * >(argp5);
  (arg1)->setTransform((SbVec3d const &)*arg2,(SbDPRotation const &)*arg3,(SbVec3d const &)*arg4,(SbDPRotation const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setTransform__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbDPRotation *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  SbDPRotation *arg5 = 0 ;
  SbVec3d *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_setTransform" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "3"" of type '" "SbDPRotation const &""'"); 
  }
  arg3 = reinterpret_cast< SbDPRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "4"" of type '" "SbVec3d const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbDPMatrix_setTransform" "', argument " "5"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "5"" of type '" "SbDPRotation const &""'"); 
  }
  arg5 = reinterpret_cast< SbDPRotation * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbDPMatrix_setTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_setTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3d * >(argp6);
  (arg1)->setTransform((SbVec3d const &)*arg2,(SbDPRotation const &)*arg3,(SbVec3d const &)*arg4,(SbDPRotation const &)*arg5,(SbVec3d const &)*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_setTransform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_setTransform", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbDPMatrix_setTransform__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbDPMatrix_setTransform__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SbDPMatrix_setTransform__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_setTransform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::setTransform(SbVec3d const &,SbDPRotation const &,SbVec3d const &)\n"
    "    SbDPMatrix::setTransform(SbVec3d const &,SbDPRotation const &,SbVec3d const &,SbDPRotation const &)\n"
    "    SbDPMatrix::setTransform(SbVec3d const &,SbDPRotation const &,SbVec3d const &,SbDPRotation const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getTransform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbDPRotation *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  SbDPRotation *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_getTransform" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_getTransform" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_getTransform" "', argument " "3"" of type '" "SbDPRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "3"" of type '" "SbDPRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbDPRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_getTransform" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbDPRotation,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbDPMatrix_getTransform" "', argument " "5"" of type '" "SbDPRotation &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "5"" of type '" "SbDPRotation &""'"); 
  }
  arg5 = reinterpret_cast< SbDPRotation * >(argp5);
  ((SbDPMatrix const *)arg1)->getTransform(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getTransform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbDPRotation *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  SbDPRotation *arg5 = 0 ;
  SbVec3d *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_getTransform" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_getTransform" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "2"" of type '" "SbVec3d &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_getTransform" "', argument " "3"" of type '" "SbDPRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "3"" of type '" "SbDPRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbDPRotation * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_getTransform" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbDPRotation,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbDPMatrix_getTransform" "', argument " "5"" of type '" "SbDPRotation &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "5"" of type '" "SbDPRotation &""'"); 
  }
  arg5 = reinterpret_cast< SbDPRotation * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbDPMatrix_getTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_getTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3d * >(argp6);
  ((SbDPMatrix const *)arg1)->getTransform(*arg2,*arg3,*arg4,*arg5,(SbVec3d const &)*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_getTransform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_getTransform", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbDPMatrix_getTransform__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SbDPMatrix_getTransform__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_getTransform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::getTransform(SbVec3d &,SbDPRotation &,SbVec3d &,SbDPRotation &) const\n"
    "    SbDPMatrix::getTransform(SbVec3d &,SbDPRotation &,SbVec3d &,SbDPRotation &,SbVec3d const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_factor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  SbDPMatrix *arg4 = 0 ;
  SbVec3d *arg5 = 0 ;
  SbDPMatrix *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_factor", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_factor" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_factor" "', argument " "2"" of type '" "SbDPMatrix &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_factor" "', argument " "2"" of type '" "SbDPMatrix &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_factor" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_factor" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbDPMatrix,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPMatrix_factor" "', argument " "4"" of type '" "SbDPMatrix &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_factor" "', argument " "4"" of type '" "SbDPMatrix &""'"); 
  }
  arg4 = reinterpret_cast< SbDPMatrix * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbDPMatrix_factor" "', argument " "5"" of type '" "SbVec3d &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_factor" "', argument " "5"" of type '" "SbVec3d &""'"); 
  }
  arg5 = reinterpret_cast< SbVec3d * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbDPMatrix,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SbDPMatrix_factor" "', argument " "6"" of type '" "SbDPMatrix &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_factor" "', argument " "6"" of type '" "SbDPMatrix &""'"); 
  }
  arg6 = reinterpret_cast< SbDPMatrix * >(argp6);
  result = (SbBool)(arg1)->factor(*arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_LUDecomposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  int *arg2 = (int *)0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_LUDecomposition", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_LUDecomposition" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_LUDecomposition" "', argument " "2"" of type '" "int [4]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_LUDecomposition" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_LUDecomposition" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (SbBool)(arg1)->LUDecomposition(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_LUBackSubstitution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  int *arg2 = (int *)0 ;
  double *arg3 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_LUBackSubstitution", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_LUBackSubstitution" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_LUBackSubstitution" "', argument " "2"" of type '" "int [4]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_LUBackSubstitution" "', argument " "3"" of type '" "double [4]""'"); 
  } 
  arg3 = reinterpret_cast< double * >(argp3);
  ((SbDPMatrix const *)arg1)->LUBackSubstitution(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_transpose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPMatrix result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_transpose" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = ((SbDPMatrix const *)arg1)->transpose();
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_multRight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multRight" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multRight" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multRight" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (SbDPMatrix *) &(arg1)->multRight((SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_multLeft", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multLeft" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multLeft" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multLeft" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (SbDPMatrix *) &(arg1)->multLeft((SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multMatrixVec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_multMatrixVec", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multMatrixVec" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multMatrixVec" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multMatrixVec" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_multMatrixVec" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multMatrixVec" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbDPMatrix const *)arg1)->multMatrixVec((SbVec3d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multVecMatrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multVecMatrix" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbDPMatrix const *)arg1)->multVecMatrix((SbVec3d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multDirMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_multDirMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multDirMatrix" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multDirMatrix" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multDirMatrix" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_multDirMatrix" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multDirMatrix" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbDPMatrix const *)arg1)->multDirMatrix((SbVec3d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multLineMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPLine *arg2 = 0 ;
  SbDPLine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_multLineMatrix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multLineMatrix" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multLineMatrix" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multLineMatrix" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPLine,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_multLineMatrix" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multLineMatrix" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  arg3 = reinterpret_cast< SbDPLine * >(argp3);
  ((SbDPMatrix const *)arg1)->multLineMatrix((SbDPLine const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multVecMatrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec4d *arg2 = 0 ;
  SbVec4d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multVecMatrix" "', argument " "2"" of type '" "SbVec4d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec4d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPMatrix_multVecMatrix" "', argument " "3"" of type '" "SbVec4d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix_multVecMatrix" "', argument " "3"" of type '" "SbVec4d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec4d * >(argp3);
  ((SbDPMatrix const *)arg1)->multVecMatrix((SbVec4d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_multVecMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix_multVecMatrix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPMatrix_multVecMatrix__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec4d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPMatrix_multVecMatrix__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPMatrix_multVecMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPMatrix::multVecMatrix(SbVec3d const &,SbVec3d &) const\n"
    "    SbDPMatrix::multVecMatrix(SbVec4d const &,SbVec4d &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix_output" "', argument " "1"" of type '" "SbDPMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbDPMatrix const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbDPMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___imul__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___imul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___imul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (SbDPMatrix *) &(arg1)->operator *=((SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPMatrix result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___mul__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___mul__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = SbDPMatrix___mul____SWIG_0(arg1,(SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___mul__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___mul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___mul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = SbDPMatrix___mul____SWIG_1(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPMatrix___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPMatrix___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPMatrix___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___rmul__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___rmul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___rmul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = SbDPMatrix___rmul__(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___eq__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___eq__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___eq__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (int)SbDPMatrix___eq__(arg1,(SbDPMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPMatrix___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPMatrix___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPMatrix___ne__" "', argument " "1"" of type '" "SbDPMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPMatrix___ne__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPMatrix___ne__" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (int)SbDPMatrix___ne__(arg1,(SbDPMatrix const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SbDPMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDPMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDPMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGeo_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeo_init", 0, 0, 0)) SWIG_fail;
  SoGeo::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeo_toGD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeo_toGD", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeo_toGD" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGeo_toGD" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGeo_toGD" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_toGD" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  result = SoGeo::toGD((SbString const *)arg1,arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeo_fromGD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbString *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeo_fromGD", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeo_fromGD" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_fromGD" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeo_fromGD" "', argument " "2"" of type '" "SbString const *""'"); 
  }
  arg2 = reinterpret_cast< SbString * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGeo_fromGD" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = SoGeo::fromGD((SbVec3d const &)*arg1,(SbString const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeo_calculateDPTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  SbString *arg4 = 0 ;
  int arg5 ;
  SbVec3d *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  SbDPMatrix result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeo_calculateDPTransform", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeo_calculateDPTransform" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGeo_calculateDPTransform" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGeo_calculateDPTransform" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_calculateDPTransform" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGeo_calculateDPTransform" "', argument " "4"" of type '" "SbString const *""'"); 
  }
  arg4 = reinterpret_cast< SbString * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGeo_calculateDPTransform" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoGeo_calculateDPTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_calculateDPTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3d * >(argp6);
  result = SoGeo::calculateDPTransform((SbString const *)arg1,arg2,(SbVec3d const &)*arg3,(SbString const *)arg4,arg5,(SbVec3d const &)*arg6);
  resultobj = SWIG_NewPointerObj((new SbDPMatrix(result)), SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeo_calculateTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int arg2 ;
  SbVec3d *arg3 = 0 ;
  SbString *arg4 = 0 ;
  int arg5 ;
  SbVec3d *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  SbMatrix result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeo_calculateTransform", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeo_calculateTransform" "', argument " "1"" of type '" "SbString const *""'"); 
  }
  arg1 = reinterpret_cast< SbString * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGeo_calculateTransform" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGeo_calculateTransform" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_calculateTransform" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoGeo_calculateTransform" "', argument " "4"" of type '" "SbString const *""'"); 
  }
  arg4 = reinterpret_cast< SbString * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoGeo_calculateTransform" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoGeo_calculateTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoGeo_calculateTransform" "', argument " "6"" of type '" "SbVec3d const &""'"); 
  }
  arg6 = reinterpret_cast< SbVec3d * >(argp6);
  result = SoGeo::calculateTransform((SbString const *)arg1,arg2,(SbVec3d const &)*arg3,(SbString const *)arg4,arg5,(SbVec3d const &)*arg6);
  resultobj = SWIG_NewPointerObj((new SbMatrix(result)), SWIGTYPE_p_SbMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGeo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGeo", 0, 0, 0)) SWIG_fail;
  result = (SoGeo *)new SoGeo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGeo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoGeo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoGeo" "', argument " "1"" of type '" "SoGeo *""'"); 
  }
  arg1 = reinterpret_cast< SoGeo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGeo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGeo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGeo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoProto__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoProto *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoProto" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SoProto *)new SoProto(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoProto__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoProto *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoProto *)new SoProto();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoProto(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoProto", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoProto__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoProto__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoProto'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoProto::SoProto(SbBool const)\n"
    "    SoProto::SoProto()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoProto_setFetchExternProtoCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFetchExternProtoCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_setFetchExternProtoCallback", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoProto_setFetchExternProtoCallback" "', argument " "1"" of type '" "SoFetchExternProtoCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProto_setFetchExternProtoCallback" "', argument " "2"" of type '" "void *""'"); 
  }
  SoProto::setFetchExternProtoCallback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_getTypeId" "', argument " "1"" of type '" "SoProto const *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  result = ((SoProto const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProto::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_findProto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProto *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (SoProto *)SoProto::findProto((SbName const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, 0 |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_initClass", 0, 0, 0)) SWIG_fail;
  SoProto::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_createProtoInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProtoInstance *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_createProtoInstance" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  result = (SoProtoInstance *)(arg1)->createProtoInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_addISReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbName *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_addISReference", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_addISReference" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProto_addISReference" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  (arg1)->addISReference(arg2,(SbName const &)*arg3,(SbName const &)*arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_findISReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  SbName result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_findISReference", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_findISReference" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProto_findISReference" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (arg1)->findISReference((SoFieldContainer const *)arg2,(SbName const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_addReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SoBase *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_addReference", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_addReference" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoProto_addReference" "', argument " "3"" of type '" "SoBase *""'"); 
  }
  arg3 = reinterpret_cast< SoBase * >(argp3);
  (arg1)->addReference((SbName const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_removeReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_removeReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_removeReference" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->removeReference((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_findReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoBase *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_findReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_findReference" "', argument " "1"" of type '" "SoProto const *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SoBase *)((SoProto const *)arg1)->findReference((SbName const &)*arg2);
  {
    resultobj = autocast_base(result);
  }
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_addRoute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SbName *arg2 = 0 ;
  SbName *arg3 = 0 ;
  SbName *arg4 = 0 ;
  SbName *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_addRoute", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_addRoute" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[3]))
    {
      arg4 = new SbName(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg4 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg4 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[4]))
    {
      arg5 = new SbName(PyBytes_AsString(swig_obj[4]));
    }
    else if  (PyUnicode_Check(swig_obj[4])){
      arg5 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[4], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg5 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[4], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg5 = *tmp;
    }
  }
  (arg1)->addRoute((SbName const &)*arg2,(SbName const &)*arg3,(SbName const &)*arg4,(SbName const &)*arg5);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_getProtoName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_getProtoName" "', argument " "1"" of type '" "SoProto const *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  result = ((SoProto const *)arg1)->getProtoName();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_readInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_readInstance", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_readInstance" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProto_readInstance" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoProto_readInstance" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (SbBool)(arg1)->readInstance(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProto_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProto_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProto_write" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProto_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProto_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProto, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoProto_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoProtoInstance_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProtoInstance_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProtoInstance::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_getTypeId" "', argument " "1"" of type '" "SoProtoInstance const *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  result = ((SoProtoInstance const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProtoInstance_initClass", 0, 0, 0)) SWIG_fail;
  SoProtoInstance::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoProtoInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProto *arg1 = 0 ;
  SoFieldData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SoProtoInstance *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoProtoInstance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProto, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoProtoInstance" "', argument " "1"" of type '" "SoProto *""'"); 
  }
  arg1 = reinterpret_cast< SoProto * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoProtoInstance" "', argument " "2"" of type '" "SoFieldData const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldData * >(argp2);
  result = (SoProtoInstance *)new SoProtoInstance(arg1,(SoFieldData const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProtoInstance, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_findProtoInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProtoInstance *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_findProtoInstance" "', argument " "1"" of type '" "SoNode const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  result = (SoProtoInstance *)SoProtoInstance::findProtoInstance((SoNode const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_setRootNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProtoInstance_setRootNode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_setRootNode" "', argument " "1"" of type '" "SoProtoInstance *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProtoInstance_setRootNode" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setRootNode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_getRootNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_getRootNode" "', argument " "1"" of type '" "SoProtoInstance *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  result = (SoNode *)(arg1)->getRootNode();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_getProtoDefinition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoProto *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_getProtoDefinition" "', argument " "1"" of type '" "SoProtoInstance const *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  result = (SoProto *)((SoProtoInstance const *)arg1)->getProtoDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProto, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_getProtoName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_getProtoName" "', argument " "1"" of type '" "SoProtoInstance const *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  result = ((SoProtoInstance const *)arg1)->getProtoName();
  resultobj = SWIG_NewPointerObj((new SbName(result)), SWIGTYPE_p_SbName, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProtoInstance_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProtoInstance *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProtoInstance_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProtoInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProtoInstance_write" "', argument " "1"" of type '" "SoProtoInstance *""'"); 
  }
  arg1 = reinterpret_cast< SoProtoInstance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProtoInstance_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProtoInstance_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProtoInstance, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoProtoInstance_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTranReceiver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTranReceiver *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTranReceiver" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  result = (SoTranReceiver *)new SoTranReceiver(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTranReceiver, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTranReceiver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranReceiver *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranReceiver, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTranReceiver" "', argument " "1"" of type '" "SoTranReceiver *""'"); 
  }
  arg1 = reinterpret_cast< SoTranReceiver * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranReceiver_interpret(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranReceiver *arg1 = 0 ;
  SoInput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranReceiver_interpret", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranReceiver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranReceiver_interpret" "', argument " "1"" of type '" "SoTranReceiver *""'"); 
  }
  arg1 = reinterpret_cast< SoTranReceiver * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranReceiver_interpret" "', argument " "2"" of type '" "SoInput *""'"); 
  }
  arg2 = reinterpret_cast< SoInput * >(argp2);
  result = (SbBool)(arg1)->interpret(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTranReceiver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTranReceiver, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTranReceiver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTranSender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOutput *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoTranSender *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoTranSender" "', argument " "1"" of type '" "SoOutput *""'"); 
  }
  arg1 = reinterpret_cast< SoOutput * >(argp1);
  result = (SoTranSender *)new SoTranSender(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTranSender, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTranSender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTranSender" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_getOutput(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_getOutput" "', argument " "1"" of type '" "SoTranSender const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  result = (SoOutput *)((SoTranSender const *)arg1)->getOutput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_insert" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranSender_insert" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->insert(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_insert" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranSender_insert" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTranSender_insert" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoTranSender_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->insert(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoTranSender_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTranSender, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoTranSender_insert__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoTranSender, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoTranSender_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoTranSender_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTranSender::insert(SoNode *)\n"
    "    SoTranSender::insert(SoNode *,SoNode *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTranSender_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranSender_remove", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_remove" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranSender_remove" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTranSender_remove" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->remove(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  SoNode *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranSender_replace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_replace" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranSender_replace" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoTranSender_replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTranSender_replace" "', argument " "4"" of type '" "SoNode *""'"); 
  }
  arg4 = reinterpret_cast< SoNode * >(argp4);
  (arg1)->replace(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_modify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranSender_modify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_modify" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranSender_modify" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->modify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranSender_prepareToSend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranSender *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranSender, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranSender_prepareToSend" "', argument " "1"" of type '" "SoTranSender *""'"); 
  }
  arg1 = reinterpret_cast< SoTranSender * >(argp1);
  (arg1)->prepareToSend();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTranSender_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTranSender, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTranSender_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAppearanceKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAppearanceKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAppearanceKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAppearanceKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAppearanceKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAppearanceKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAppearanceKit_getTypeId" "', argument " "1"" of type '" "SoAppearanceKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoAppearanceKit * >(argp1);
  result = ((SoAppearanceKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAppearanceKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAppearanceKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoAppearanceKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAppearanceKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAppearanceKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAppearanceKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAppearanceKit_getNodekitCatalog" "', argument " "1"" of type '" "SoAppearanceKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoAppearanceKit * >(argp1);
  result = (SoNodekitCatalog *)((SoAppearanceKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAppearanceKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAppearanceKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAppearanceKit", 0, 0, 0)) SWIG_fail;
  result = (SoAppearanceKit *)new SoAppearanceKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAppearanceKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAppearanceKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAppearanceKit_initClass", 0, 0, 0)) SWIG_fail;
  SoAppearanceKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAppearanceKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAppearanceKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAppearanceKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCameraKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCameraKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCameraKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCameraKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCameraKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCameraKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCameraKit_getTypeId" "', argument " "1"" of type '" "SoCameraKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoCameraKit * >(argp1);
  result = ((SoCameraKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCameraKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCameraKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoCameraKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCameraKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCameraKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCameraKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCameraKit_getNodekitCatalog" "', argument " "1"" of type '" "SoCameraKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoCameraKit * >(argp1);
  result = (SoNodekitCatalog *)((SoCameraKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCameraKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCameraKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCameraKit", 0, 0, 0)) SWIG_fail;
  result = (SoCameraKit *)new SoCameraKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCameraKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCameraKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCameraKit_initClass", 0, 0, 0)) SWIG_fail;
  SoCameraKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCameraKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCameraKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCameraKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLightKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLightKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightKit_getTypeId" "', argument " "1"" of type '" "SoLightKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightKit * >(argp1);
  result = ((SoLightKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoLightKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLightKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLightKit_getNodekitCatalog" "', argument " "1"" of type '" "SoLightKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoLightKit * >(argp1);
  result = (SoNodekitCatalog *)((SoLightKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLightKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLightKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLightKit", 0, 0, 0)) SWIG_fail;
  result = (SoLightKit *)new SoLightKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLightKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLightKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLightKit_initClass", 0, 0, 0)) SWIG_fail;
  SoLightKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLightKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLightKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLightKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNodeKit_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeKit_init", 0, 0, 0)) SWIG_fail;
  SoNodeKit::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodeKit", 0, 0, 0)) SWIG_fail;
  result = (SoNodeKit *)new SoNodeKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeKit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNodeKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeKit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNodeKit" "', argument " "1"" of type '" "SoNodeKit *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeKit * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodeKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSceneKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSceneKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneKit_getTypeId" "', argument " "1"" of type '" "SoSceneKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneKit * >(argp1);
  result = ((SoSceneKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoSceneKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneKit_getNodekitCatalog" "', argument " "1"" of type '" "SoSceneKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneKit * >(argp1);
  result = (SoNodekitCatalog *)((SoSceneKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneKit_initClass", 0, 0, 0)) SWIG_fail;
  SoSceneKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSceneKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSceneKit", 0, 0, 0)) SWIG_fail;
  result = (SoSceneKit *)new SoSceneKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_getCameraNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneKit_getCameraNumber" "', argument " "1"" of type '" "SoSceneKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneKit * >(argp1);
  result = (int)(arg1)->getCameraNumber();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_setCameraNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneKit_setCameraNumber", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneKit_setCameraNumber" "', argument " "1"" of type '" "SoSceneKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneKit * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneKit_setCameraNumber" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setCameraNumber(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneKit_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneKit_affectsState" "', argument " "1"" of type '" "SoSceneKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneKit * >(argp1);
  result = (SbBool)((SoSceneKit const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSceneKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSceneKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSceneKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSeparatorKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSeparatorKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_getTypeId" "', argument " "1"" of type '" "SoSeparatorKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = ((SoSeparatorKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoSeparatorKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_getNodekitCatalog" "', argument " "1"" of type '" "SoSeparatorKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = (SoNodekitCatalog *)((SoSeparatorKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSeparatorKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSeparatorKit", 0, 0, 0)) SWIG_fail;
  result = (SoSeparatorKit *)new SoSeparatorKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparatorKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_renderCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_renderCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_renderCaching_set" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparatorKit_renderCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_renderCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_renderCaching_get" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_boundingBoxCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_boundingBoxCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_boundingBoxCaching_set" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparatorKit_boundingBoxCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->boundingBoxCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_boundingBoxCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_boundingBoxCaching_get" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->boundingBoxCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_renderCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_renderCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_renderCulling_set" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparatorKit_renderCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_renderCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_renderCulling_get" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_pickCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_pickCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_pickCulling_set" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparatorKit_pickCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->pickCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_pickCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparatorKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparatorKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparatorKit_pickCulling_get" "', argument " "1"" of type '" "SoSeparatorKit *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparatorKit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->pickCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparatorKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparatorKit_initClass", 0, 0, 0)) SWIG_fail;
  SoSeparatorKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSeparatorKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSeparatorKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSeparatorKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShapeKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShapeKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeKit_getTypeId" "', argument " "1"" of type '" "SoShapeKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeKit * >(argp1);
  result = ((SoShapeKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoShapeKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShapeKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShapeKit_getNodekitCatalog" "', argument " "1"" of type '" "SoShapeKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoShapeKit * >(argp1);
  result = (SoNodekitCatalog *)((SoShapeKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShapeKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShapeKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShapeKit", 0, 0, 0)) SWIG_fail;
  result = (SoShapeKit *)new SoShapeKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShapeKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShapeKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShapeKit_initClass", 0, 0, 0)) SWIG_fail;
  SoShapeKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShapeKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShapeKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShapeKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoWrapperKit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWrapperKit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoWrapperKit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWrapperKit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWrapperKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWrapperKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWrapperKit_getTypeId" "', argument " "1"" of type '" "SoWrapperKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoWrapperKit * >(argp1);
  result = ((SoWrapperKit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWrapperKit_getClassNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWrapperKit_getClassNodekitCatalog", 0, 0, 0)) SWIG_fail;
  result = (SoNodekitCatalog *)SoWrapperKit::getClassNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWrapperKit_getNodekitCatalog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWrapperKit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNodekitCatalog *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWrapperKit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWrapperKit_getNodekitCatalog" "', argument " "1"" of type '" "SoWrapperKit const *""'"); 
  }
  arg1 = reinterpret_cast< SoWrapperKit * >(argp1);
  result = (SoNodekitCatalog *)((SoWrapperKit const *)arg1)->getNodekitCatalog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodekitCatalog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWrapperKit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWrapperKit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoWrapperKit", 0, 0, 0)) SWIG_fail;
  result = (SoWrapperKit *)new SoWrapperKit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoWrapperKit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWrapperKit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWrapperKit_initClass", 0, 0, 0)) SWIG_fail;
  SoWrapperKit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoWrapperKit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoWrapperKit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoWrapperKit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGroup_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGroup::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getTypeId" "', argument " "1"" of type '" "SoGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  result = ((SoGroup const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_initClass", 0, 0, 0)) SWIG_fail;
  SoGroup::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoGroup *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoGroup *)new SoGroup();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGroup, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoGroup *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoGroup" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoGroup *)new SoGroup(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGroup, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoGroup", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoGroup__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoGroup__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGroup::SoGroup()\n"
    "    SoGroup::SoGroup(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGroup_addChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_addChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_addChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_insertChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_insertChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_insertChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGroup_insertChild" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getChild" "', argument " "1"" of type '" "SoGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGroup_getChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoGroup const *)arg1)->getChild(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_findChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_findChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_findChild" "', argument " "1"" of type '" "SoGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_findChild" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoGroup const *)arg1)->findChild((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getNumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getNumChildren" "', argument " "1"" of type '" "SoGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  result = (int)((SoGroup const *)arg1)->getNumChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_removeChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_removeChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGroup_removeChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_removeChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_removeChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_removeChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_removeChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGroup_removeChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGroup_removeChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoGroup_removeChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGroup_removeChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGroup::removeChild(int)\n"
    "    SoGroup::removeChild(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGroup_removeAllChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_removeAllChildren" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  (arg1)->removeAllChildren();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_replaceChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_replaceChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGroup_replaceChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGroup_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_replaceChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_replaceChild" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_replaceChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoGroup_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGroup_replaceChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGroup_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoGroup_replaceChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGroup_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGroup::replaceChild(int,SoNode *)\n"
    "    SoGroup::replaceChild(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGroup_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_doAction" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_GLRender" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_callback" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getBoundingBox" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getMatrix" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_handleEvent" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_pick" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_search" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_write" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getPrimitiveCount" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_audioRender" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_getChildren" "', argument " "1"" of type '" "SoGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  result = (SoChildList *)((SoGroup const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_addWriteReference__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_addWriteReference" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoGroup_addWriteReference" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->addWriteReference(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_addWriteReference__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup_addWriteReference" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup_addWriteReference" "', argument " "2"" of type '" "SoOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoOutput * >(argp2);
  (arg1)->addWriteReference(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup_addWriteReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoGroup_addWriteReference", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoGroup_addWriteReference__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoOutput, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoGroup_addWriteReference__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoGroup_addWriteReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoGroup::addWriteReference(SoOutput *,SbBool)\n"
    "    SoGroup::addWriteReference(SoOutput *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoGroup___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup___len__" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  result = (int)SoGroup___len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup___contains__" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGroup___contains__" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)SoGroup___contains__(arg1,(SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGroup___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGroup *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGroup___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGroup___getitem__" "', argument " "1"" of type '" "SoGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoGroup___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)SoGroup___getitem__(arg1,arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGroup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGroup_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSeparator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSeparator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_getTypeId" "', argument " "1"" of type '" "SoSeparator const *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = ((SoSeparator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_initClass", 0, 0, 0)) SWIG_fail;
  SoSeparator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSeparator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoSeparator *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoSeparator *)new SoSeparator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSeparator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoSeparator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoSeparator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoSeparator *)new SoSeparator(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSeparator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoSeparator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoSeparator__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoSeparator__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoSeparator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSeparator::SoSeparator()\n"
    "    SoSeparator::SoSeparator(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSeparator_renderCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_renderCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_renderCaching_set" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_renderCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_renderCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_renderCaching_get" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_boundingBoxCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_boundingBoxCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_boundingBoxCaching_set" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_boundingBoxCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->boundingBoxCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_boundingBoxCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_boundingBoxCaching_get" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = (SoSFEnum *)& ((arg1)->boundingBoxCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_renderCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_renderCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_renderCulling_set" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_renderCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_renderCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_renderCulling_get" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_pickCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_pickCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_pickCulling_set" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_pickCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->pickCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_pickCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_pickCulling_get" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = (SoSFEnum *)& ((arg1)->pickCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_doAction" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_GLRender" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_GLRenderBelowPath" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_GLRenderInPath" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_GLRenderOffPath" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_callback" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_getBoundingBox" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_getMatrix" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_handleEvent" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_rayPick" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_search" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_getPrimitiveCount" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_audioRender" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_notify" "', argument " "1"" of type '" "SoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSeparator_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_setNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoSeparator_setNumRenderCaches" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SoSeparator::setNumRenderCaches(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_getNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSeparator_getNumRenderCaches", 0, 0, 0)) SWIG_fail;
  result = (int)SoSeparator::getNumRenderCaches();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSeparator_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSeparator_affectsState" "', argument " "1"" of type '" "SoSeparator const *""'"); 
  }
  arg1 = reinterpret_cast< SoSeparator * >(argp1);
  result = (SbBool)((SoSeparator const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSeparator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSeparator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSeparator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAnnotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAnnotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnotation_getTypeId" "', argument " "1"" of type '" "SoAnnotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnotation * >(argp1);
  result = ((SoAnnotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_initClass", 0, 0, 0)) SWIG_fail;
  SoAnnotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAnnotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAnnotation", 0, 0, 0)) SWIG_fail;
  result = (SoAnnotation *)new SoAnnotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAnnotation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnotation_GLRender" "', argument " "1"" of type '" "SoAnnotation *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnotation_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnotation_GLRenderBelowPath" "', argument " "1"" of type '" "SoAnnotation *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnotation_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnotation_GLRenderInPath" "', argument " "1"" of type '" "SoAnnotation *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnotation_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAnnotation_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAnnotation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAnnotation_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAnnotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAnnotation_GLRenderOffPath" "', argument " "1"" of type '" "SoAnnotation *""'"); 
  }
  arg1 = reinterpret_cast< SoAnnotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAnnotation_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAnnotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAnnotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAnnotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAntiSquish_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAntiSquish_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAntiSquish::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_getTypeId" "', argument " "1"" of type '" "SoAntiSquish const *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  result = ((SoAntiSquish const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAntiSquish_initClass", 0, 0, 0)) SWIG_fail;
  SoAntiSquish::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAntiSquish(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAntiSquish", 0, 0, 0)) SWIG_fail;
  result = (SoAntiSquish *)new SoAntiSquish();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAntiSquish, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_sizing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAntiSquish_sizing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_sizing_set" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAntiSquish_sizing_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->sizing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_sizing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_sizing_get" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  result = (SoSFEnum *)& ((arg1)->sizing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_recalcAlways_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAntiSquish_recalcAlways_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_recalcAlways_set" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAntiSquish_recalcAlways_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->recalcAlways = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_recalcAlways_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_recalcAlways_get" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  result = (SoSFBool *)& ((arg1)->recalcAlways);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_recalc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_recalc" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  (arg1)->recalc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAntiSquish_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAntiSquish *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAntiSquish_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAntiSquish, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAntiSquish_doAction" "', argument " "1"" of type '" "SoAntiSquish *""'"); 
  }
  arg1 = reinterpret_cast< SoAntiSquish * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAntiSquish_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAntiSquish_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAntiSquish, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAntiSquish_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoArray_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoArray::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_getTypeId" "', argument " "1"" of type '" "SoArray const *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = ((SoArray const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_initClass", 0, 0, 0)) SWIG_fail;
  SoArray::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoArray", 0, 0, 0)) SWIG_fail;
  result = (SoArray *)new SoArray();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoArray, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_origin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_origin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_origin_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_origin_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->origin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_origin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_origin_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFEnum *)& ((arg1)->origin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_numElements1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements1_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_numElements1_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->numElements1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements1_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFShort *)& ((arg1)->numElements1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_numElements2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements2_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_numElements2_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->numElements2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements2_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFShort *)& ((arg1)->numElements2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFShort *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_numElements3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements3_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFShort, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_numElements3_set" "', argument " "2"" of type '" "SoSFShort *""'"); 
  }
  arg2 = reinterpret_cast< SoSFShort * >(argp2);
  if (arg1) (arg1)->numElements3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_numElements3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFShort *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_numElements3_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFShort *)& ((arg1)->numElements3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFShort, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_separation1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation1_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_separation1_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->separation1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation1_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->separation1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_separation2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation2_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_separation2_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->separation2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation2_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->separation2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_separation3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation3_set" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_separation3_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->separation3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_separation3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_separation3_get" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->separation3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_affectsState" "', argument " "1"" of type '" "SoArray const *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  result = (SbBool)((SoArray const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_doAction" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_callback" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_GLRender" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_pick" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_getBoundingBox" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_handleEvent" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_getMatrix" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_search" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_getPrimitiveCount" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoArray_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoArray *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoArray_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoArray_audioRender" "', argument " "1"" of type '" "SoArray *""'"); 
  }
  arg1 = reinterpret_cast< SoArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoArray_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoArray, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAsciiText_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAsciiText::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_getTypeId" "', argument " "1"" of type '" "SoAsciiText const *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  result = ((SoAsciiText const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_initClass", 0, 0, 0)) SWIG_fail;
  SoAsciiText::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAsciiText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAsciiText", 0, 0, 0)) SWIG_fail;
  result = (SoAsciiText *)new SoAsciiText();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAsciiText, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_string_set" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_string_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->string = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_string_get" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  result = (SoMFString *)& ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_spacing_set" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_spacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->spacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_spacing_get" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  result = (SoSFFloat *)& ((arg1)->spacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_justification_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_justification_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_justification_set" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_justification_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->justification = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_justification_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_justification_get" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  result = (SoSFEnum *)& ((arg1)->justification);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_width_set" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_width_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->width = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_width_get" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  result = (SoMFFloat *)& ((arg1)->width);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_GLRender" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAsciiText_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAsciiText *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAsciiText_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAsciiText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAsciiText_getPrimitiveCount" "', argument " "1"" of type '" "SoAsciiText *""'"); 
  }
  arg1 = reinterpret_cast< SoAsciiText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAsciiText_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAsciiText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAsciiText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAsciiText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBaseColor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBaseColor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_getTypeId" "', argument " "1"" of type '" "SoBaseColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  result = ((SoBaseColor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_initClass", 0, 0, 0)) SWIG_fail;
  SoBaseColor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBaseColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBaseColor", 0, 0, 0)) SWIG_fail;
  result = (SoBaseColor *)new SoBaseColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBaseColor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_rgb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_rgb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_rgb_set" "', argument " "1"" of type '" "SoBaseColor *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseColor_rgb_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->rgb = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_rgb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_rgb_get" "', argument " "1"" of type '" "SoBaseColor *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  result = (SoMFColor *)& ((arg1)->rgb);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_doAction" "', argument " "1"" of type '" "SoBaseColor *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseColor_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_GLRender" "', argument " "1"" of type '" "SoBaseColor *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseColor_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBaseColor_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBaseColor *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBaseColor_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBaseColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBaseColor_callback" "', argument " "1"" of type '" "SoBaseColor *""'"); 
  }
  arg1 = reinterpret_cast< SoBaseColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBaseColor_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBaseColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBaseColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBaseColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSwitch_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSwitch::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_getTypeId" "', argument " "1"" of type '" "SoSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  result = ((SoSwitch const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_initClass", 0, 0, 0)) SWIG_fail;
  SoSwitch::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSwitch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoSwitch *)new SoSwitch();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSwitch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoSwitch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoSwitch *)new SoSwitch(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSwitch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoSwitch", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoSwitch__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoSwitch__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoSwitch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSwitch::SoSwitch()\n"
    "    SoSwitch::SoSwitch(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSwitch_whichChild_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_whichChild_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_whichChild_set" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_whichChild_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->whichChild = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_whichChild_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_whichChild_get" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->whichChild);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_affectsState" "', argument " "1"" of type '" "SoSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  result = (SbBool)((SoSwitch const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_doAction" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_callback" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_GLRender" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_pick" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_getBoundingBox" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_handleEvent" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_getMatrix" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_search" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_write" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_getPrimitiveCount" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_audioRender" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSwitch_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSwitch *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSwitch_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSwitch_notify" "', argument " "1"" of type '" "SoSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSwitch_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSwitch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSwitch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSwitch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBlinker_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBlinker::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_getTypeId" "', argument " "1"" of type '" "SoBlinker const *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  result = ((SoBlinker const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_initClass", 0, 0, 0)) SWIG_fail;
  SoBlinker::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBlinker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBlinker", 0, 0, 0)) SWIG_fail;
  result = (SoBlinker *)new SoBlinker();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBlinker, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_speed_set" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBlinker_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_speed_get" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_on_set" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBlinker_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_on_get" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_getBoundingBox" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBlinker_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBlinker_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBlinker *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBlinker_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBlinker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBlinker_write" "', argument " "1"" of type '" "SoBlinker *""'"); 
  }
  arg1 = reinterpret_cast< SoBlinker * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBlinker_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBlinker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBlinker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBlinker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMapCoordinate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_getTypeId" "', argument " "1"" of type '" "SoBumpMapCoordinate const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  result = ((SoBumpMapCoordinate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMapCoordinate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBumpMapCoordinate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBumpMapCoordinate", 0, 0, 0)) SWIG_fail;
  result = (SoBumpMapCoordinate *)new SoBumpMapCoordinate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBumpMapCoordinate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_point_set" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinate_point_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_point_get" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_doAction" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinate_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_GLRender" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinate_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_callback" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinate_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapCoordinate_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapCoordinate *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapCoordinate_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapCoordinate_pick" "', argument " "1"" of type '" "SoBumpMapCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapCoordinate_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMapCoordinate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMapCoordinate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBumpMapCoordinate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBumpMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_getTypeId" "', argument " "1"" of type '" "SoBumpMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  result = ((SoBumpMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBumpMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBumpMap", 0, 0, 0)) SWIG_fail;
  result = (SoBumpMap *)new SoBumpMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBumpMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_filename_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_filename_set" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_filename_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->filename = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_filename_get" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  result = (SoSFString *)& ((arg1)->filename);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_image_set" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_image_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->image = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_image_get" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->image);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_wrapS_set" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_wrapS_get" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_wrapT_set" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_wrapT_get" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_doAction" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_GLRender" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_callback" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMap_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMap *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMap_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMap_rayPick" "', argument " "1"" of type '" "SoBumpMap *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMap_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBumpMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoBumpMapTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoBumpMapTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_getTypeId" "', argument " "1"" of type '" "SoBumpMapTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  result = ((SoBumpMapTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoBumpMapTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoBumpMapTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoBumpMapTransform", 0, 0, 0)) SWIG_fail;
  result = (SoBumpMapTransform *)new SoBumpMapTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoBumpMapTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_translation_set" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_translation_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_translation_get" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_rotation_set" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_rotation_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_rotation_get" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  result = (SoSFFloat *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_scaleFactor_set" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_scaleFactor_get" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_center_set" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_center_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_center_get" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_doAction" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_callback" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_GLRender" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_getMatrix" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoBumpMapTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoBumpMapTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoBumpMapTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoBumpMapTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoBumpMapTransform_pick" "', argument " "1"" of type '" "SoBumpMapTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoBumpMapTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoBumpMapTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoBumpMapTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoBumpMapTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoBumpMapTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCallback_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCallback::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_getTypeId" "', argument " "1"" of type '" "SoCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  result = ((SoCallback const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_initClass", 0, 0, 0)) SWIG_fail;
  SoCallback::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCallback", 0, 0, 0)) SWIG_fail;
  result = (SoCallback *)new SoCallback();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCallback, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_setCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoCallbackCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_setCallback" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoAction__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallback_setCallback" "', argument " "2"" of type '" "SoCallbackCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCallback_setCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_setCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoCallbackCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_setCallback" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoAction__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoCallback_setCallback" "', argument " "2"" of type '" "SoCallbackCB *""'"); 
    }
  }
  (arg1)->setCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_doAction" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_callback" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_GLRender" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_getBoundingBox" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_getMatrix" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_handleEvent" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_pick" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_search" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_write" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCallback_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_getPrimitiveCount" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCallback_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_setCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_setCallback" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoCallback_setCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_setCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCallback *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCallback_setCallback" "', argument " "1"" of type '" "SoCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoCallback * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoCallback_setCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCallback_setCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCallback_setCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoAction__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCallback_setCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoCallback_setCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoAction__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCallback_setCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoCallback_setCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCallback_setCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCallback::setCallback(SoCallbackCB *,void *)\n"
    "    SoCallback::setCallback(SoCallbackCB *)\n"
    "    SoCallback::setCallback(PyObject *,PyObject *)\n"
    "    SoCallback::setCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCallback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCamera_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCamera::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getTypeId" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = ((SoCamera const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_initClass", 0, 0, 0)) SWIG_fail;
  SoCamera::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewportMapping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_viewportMapping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewportMapping_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewportMapping_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->viewportMapping = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewportMapping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewportMapping_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFEnum *)& ((arg1)->viewportMapping);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_position_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_position_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_position_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_orientation_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_orientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_orientation_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFRotation *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_aspectRatio_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_aspectRatio_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_aspectRatio_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_aspectRatio_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->aspectRatio = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_aspectRatio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_aspectRatio_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->aspectRatio);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_nearDistance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_nearDistance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_nearDistance_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_nearDistance_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->nearDistance = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_nearDistance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_nearDistance_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->nearDistance);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_farDistance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_farDistance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_farDistance_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_farDistance_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->farDistance = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_farDistance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_farDistance_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->farDistance);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_focalDistance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_focalDistance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_focalDistance_set" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_focalDistance_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->focalDistance = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_focalDistance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_focalDistance_get" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->focalDistance);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewVolume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  SbViewportRegion *arg3 = 0 ;
  SbMatrix *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getViewVolume" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getViewVolume" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewVolume" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_getViewVolume" "', argument " "3"" of type '" "SbViewportRegion &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewVolume" "', argument " "3"" of type '" "SbViewportRegion &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoCamera_getViewVolume" "', argument " "4"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewVolume" "', argument " "4"" of type '" "SbMatrix const &""'"); 
  }
  arg4 = reinterpret_cast< SbMatrix * >(argp4);
  result = ((SoCamera const *)arg1)->getViewVolume((SbViewportRegion const &)*arg2,*arg3,(SbMatrix const &)*arg4);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewVolume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  SbViewportRegion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getViewVolume" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getViewVolume" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewVolume" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_getViewVolume" "', argument " "3"" of type '" "SbViewportRegion &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewVolume" "', argument " "3"" of type '" "SbViewportRegion &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  result = ((SoCamera const *)arg1)->getViewVolume((SbViewportRegion const &)*arg2,*arg3);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_pointAt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_pointAt" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->pointAt((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_pointAt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_pointAt" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->pointAt((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_pointAt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCamera_pointAt", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoCamera_pointAt__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCamera_pointAt__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCamera_pointAt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCamera::pointAt(SbVec3f const &)\n"
    "    SoCamera::pointAt(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCamera_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_scaleHeight" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCamera_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewVolume__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getViewVolume" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCamera_getViewVolume" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SoCamera const *)arg1)->getViewVolume(arg2);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewVolume__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getViewVolume" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = ((SoCamera const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewVolume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCamera_getViewVolume", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoCamera_getViewVolume__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoCamera_getViewVolume__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCamera_getViewVolume__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SbMatrix, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoCamera_getViewVolume__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCamera_getViewVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCamera::getViewVolume(SbViewportRegion const &,SbViewportRegion &,SbMatrix const &) const\n"
    "    SoCamera::getViewVolume(SbViewportRegion const &,SbViewportRegion &) const\n"
    "    SoCamera::getViewVolume(float) const\n"
    "    SoCamera::getViewVolume() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewAll__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbViewportRegion *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewAll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewAll" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoCamera_viewAll" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->viewAll(arg2,(SbViewportRegion const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewAll__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  SbViewportRegion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewAll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewAll" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  (arg1)->viewAll(arg2,(SbViewportRegion const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewAll__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  SbViewportRegion *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewAll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewAll" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoCamera_viewAll" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->viewAll(arg2,(SbViewportRegion const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewAll__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoPath *arg2 = (SoPath *)0 ;
  SbViewportRegion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewAll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewAll" "', argument " "2"" of type '" "SoPath *const""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_viewAll" "', argument " "3"" of type '" "SbViewportRegion const &""'"); 
  }
  arg3 = reinterpret_cast< SbViewportRegion * >(argp3);
  (arg1)->viewAll(arg2,(SbViewportRegion const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewAll(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoCamera_viewAll", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCamera_viewAll__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoCamera_viewAll__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoCamera_viewAll__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoCamera_viewAll__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoCamera_viewAll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoCamera::viewAll(SoNode *const,SbViewportRegion const &,float const)\n"
    "    SoCamera::viewAll(SoNode *const,SbViewportRegion const &)\n"
    "    SoCamera::viewAll(SoPath *const,SbViewportRegion const &,float const)\n"
    "    SoCamera::viewAll(SoPath *const,SbViewportRegion const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoCamera_getViewportBounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbViewportRegion result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_getViewportBounds", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getViewportBounds" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getViewportBounds" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_getViewportBounds" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  result = ((SoCamera const *)arg1)->getViewportBounds((SbViewportRegion const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbViewportRegion(result)), SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_setStereoMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoCamera::StereoMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_setStereoMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_setStereoMode" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCamera_setStereoMode" "', argument " "2"" of type '" "SoCamera::StereoMode""'");
  } 
  arg2 = static_cast< SoCamera::StereoMode >(val2);
  (arg1)->setStereoMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getStereoMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCamera::StereoMode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getStereoMode" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (SoCamera::StereoMode)((SoCamera const *)arg1)->getStereoMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_setStereoAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_setStereoAdjustment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_setStereoAdjustment" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCamera_setStereoAdjustment" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setStereoAdjustment(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getStereoAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getStereoAdjustment" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (float)((SoCamera const *)arg1)->getStereoAdjustment();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_setBalanceAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_setBalanceAdjustment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_setBalanceAdjustment" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCamera_setBalanceAdjustment" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setBalanceAdjustment(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getBalanceAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getBalanceAdjustment" "', argument " "1"" of type '" "SoCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  result = (float)((SoCamera const *)arg1)->getBalanceAdjustment();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_doAction" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_callback" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_GLRender" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_audioRender" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getBoundingBox" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getMatrix" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_handleEvent" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_rayPick" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_getPrimitiveCount" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCamera_viewBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCamera_viewBoundingBox", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCamera_viewBoundingBox" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCamera_viewBoundingBox" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoCamera_viewBoundingBox" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->viewBoundingBox((SbBox3f const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCamera_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCamera, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoColorIndex_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorIndex_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoColorIndex::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorIndex_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorIndex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorIndex_getTypeId" "', argument " "1"" of type '" "SoColorIndex const *""'"); 
  }
  arg1 = reinterpret_cast< SoColorIndex * >(argp1);
  result = ((SoColorIndex const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorIndex_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorIndex_initClass", 0, 0, 0)) SWIG_fail;
  SoColorIndex::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorIndex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoColorIndex", 0, 0, 0)) SWIG_fail;
  result = (SoColorIndex *)new SoColorIndex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoColorIndex, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorIndex_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorIndex *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorIndex_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorIndex_index_set" "', argument " "1"" of type '" "SoColorIndex *""'"); 
  }
  arg1 = reinterpret_cast< SoColorIndex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoColorIndex_index_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->index = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorIndex_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorIndex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorIndex_index_get" "', argument " "1"" of type '" "SoColorIndex *""'"); 
  }
  arg1 = reinterpret_cast< SoColorIndex * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->index);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoColorIndex_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoColorIndex *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoColorIndex_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoColorIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoColorIndex_GLRender" "', argument " "1"" of type '" "SoColorIndex *""'"); 
  }
  arg1 = reinterpret_cast< SoColorIndex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoColorIndex_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoColorIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoColorIndex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoColorIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCone_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCone::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_getTypeId" "', argument " "1"" of type '" "SoCone const *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  result = ((SoCone const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_initClass", 0, 0, 0)) SWIG_fail;
  SoCone::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCone", 0, 0, 0)) SWIG_fail;
  result = (SoCone *)new SoCone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCone, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_parts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_parts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_parts_set" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_parts_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->parts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_parts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_parts_get" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->parts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_bottomRadius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_bottomRadius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_bottomRadius_set" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_bottomRadius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->bottomRadius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_bottomRadius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_bottomRadius_get" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  result = (SoSFFloat *)& ((arg1)->bottomRadius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_height_set" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_height_get" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_addPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoCone::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_addPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_addPart" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCone_addPart" "', argument " "2"" of type '" "SoCone::Part""'");
  } 
  arg2 = static_cast< SoCone::Part >(val2);
  (arg1)->addPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_removePart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoCone::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_removePart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_removePart" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCone_removePart" "', argument " "2"" of type '" "SoCone::Part""'");
  } 
  arg2 = static_cast< SoCone::Part >(val2);
  (arg1)->removePart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_hasPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoCone::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_hasPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_hasPart" "', argument " "1"" of type '" "SoCone const *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCone_hasPart" "', argument " "2"" of type '" "SoCone::Part""'");
  } 
  arg2 = static_cast< SoCone::Part >(val2);
  result = (SbBool)((SoCone const *)arg1)->hasPart(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_GLRender" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_rayPick" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCone_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCone *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCone_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCone_getPrimitiveCount" "', argument " "1"" of type '" "SoCone *""'"); 
  }
  arg1 = reinterpret_cast< SoCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCone_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCone_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCone, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCone_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCoordinate3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCoordinate3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_getTypeId" "', argument " "1"" of type '" "SoCoordinate3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  result = ((SoCoordinate3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_initClass", 0, 0, 0)) SWIG_fail;
  SoCoordinate3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCoordinate3", 0, 0, 0)) SWIG_fail;
  result = (SoCoordinate3 *)new SoCoordinate3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCoordinate3, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_point_set" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_point_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_point_get" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_doAction" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_GLRender" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_callback" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_getBoundingBox" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_pick" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate3_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate3 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate3_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate3_getPrimitiveCount" "', argument " "1"" of type '" "SoCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate3_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCoordinate3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCoordinate3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCoordinate3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCoordinate4_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCoordinate4::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_getTypeId" "', argument " "1"" of type '" "SoCoordinate4 const *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  result = ((SoCoordinate4 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_initClass", 0, 0, 0)) SWIG_fail;
  SoCoordinate4::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCoordinate4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCoordinate4", 0, 0, 0)) SWIG_fail;
  result = (SoCoordinate4 *)new SoCoordinate4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCoordinate4, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_point_set" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_point_set" "', argument " "2"" of type '" "SoMFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_point_get" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  result = (SoMFVec4f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_doAction" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_GLRender" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_getBoundingBox" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_callback" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_pick" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCoordinate4_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCoordinate4 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCoordinate4_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCoordinate4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCoordinate4_getPrimitiveCount" "', argument " "1"" of type '" "SoCoordinate4 *""'"); 
  }
  arg1 = reinterpret_cast< SoCoordinate4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCoordinate4_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCoordinate4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCoordinate4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCoordinate4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCube_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCube::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_getTypeId" "', argument " "1"" of type '" "SoCube const *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  result = ((SoCube const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_initClass", 0, 0, 0)) SWIG_fail;
  SoCube::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCube", 0, 0, 0)) SWIG_fail;
  result = (SoCube *)new SoCube();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCube, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_width_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_width_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_width_set" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_width_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->width = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_width_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_width_get" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  result = (SoSFFloat *)& ((arg1)->width);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_height_set" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_height_get" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_depth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_depth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_depth_set" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_depth_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->depth = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_depth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_depth_get" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  result = (SoSFFloat *)& ((arg1)->depth);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_GLRender" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_rayPick" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCube_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCube *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCube_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCube_getPrimitiveCount" "', argument " "1"" of type '" "SoCube *""'"); 
  }
  arg1 = reinterpret_cast< SoCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCube_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCube_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCube, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCube_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCylinder_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCylinder::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_getTypeId" "', argument " "1"" of type '" "SoCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  result = ((SoCylinder const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_initClass", 0, 0, 0)) SWIG_fail;
  SoCylinder::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCylinder", 0, 0, 0)) SWIG_fail;
  result = (SoCylinder *)new SoCylinder();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCylinder, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_radius_set" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_radius_get" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_height_set" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_height_get" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_parts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_parts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_parts_set" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_parts_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->parts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_parts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_parts_get" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->parts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_addPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoCylinder::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_addPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_addPart" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCylinder_addPart" "', argument " "2"" of type '" "SoCylinder::Part""'");
  } 
  arg2 = static_cast< SoCylinder::Part >(val2);
  (arg1)->addPart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_removePart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoCylinder::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_removePart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_removePart" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCylinder_removePart" "', argument " "2"" of type '" "SoCylinder::Part""'");
  } 
  arg2 = static_cast< SoCylinder::Part >(val2);
  (arg1)->removePart(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_hasPart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoCylinder::Part arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_hasPart", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_hasPart" "', argument " "1"" of type '" "SoCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoCylinder_hasPart" "', argument " "2"" of type '" "SoCylinder::Part""'");
  } 
  arg2 = static_cast< SoCylinder::Part >(val2);
  result = (SbBool)((SoCylinder const *)arg1)->hasPart(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_rayPick" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_getPrimitiveCount" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCylinder_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCylinder *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCylinder_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCylinder_GLRender" "', argument " "1"" of type '" "SoCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCylinder_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCylinder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCylinder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoEnvironment_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEnvironment::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_getTypeId" "', argument " "1"" of type '" "SoEnvironment const *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = ((SoEnvironment const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_initClass", 0, 0, 0)) SWIG_fail;
  SoEnvironment::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoEnvironment", 0, 0, 0)) SWIG_fail;
  result = (SoEnvironment *)new SoEnvironment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEnvironment, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_GLRender" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_callback" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_ambientIntensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_ambientIntensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_ambientIntensity_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_ambientIntensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->ambientIntensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_ambientIntensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_ambientIntensity_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFFloat *)& ((arg1)->ambientIntensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_ambientColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_ambientColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_ambientColor_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_ambientColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->ambientColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_ambientColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_ambientColor_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFColor *)& ((arg1)->ambientColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_attenuation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_attenuation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_attenuation_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_attenuation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->attenuation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_attenuation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_attenuation_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->attenuation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_fogType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogType_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_fogType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->fogType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogType_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFEnum *)& ((arg1)->fogType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_fogColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogColor_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_fogColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->fogColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogColor_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFColor *)& ((arg1)->fogColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogVisibility_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEnvironment_fogVisibility_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogVisibility_set" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEnvironment_fogVisibility_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->fogVisibility = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEnvironment_fogVisibility_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEnvironment_fogVisibility_get" "', argument " "1"" of type '" "SoEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoEnvironment * >(argp1);
  result = (SoSFFloat *)& ((arg1)->fogVisibility);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEnvironment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEnvironment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEnvironment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoEventCallback_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventCallback_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoEventCallback::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_getTypeId" "', argument " "1"" of type '" "SoEventCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = ((SoEventCallback const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventCallback_initClass", 0, 0, 0)) SWIG_fail;
  SoEventCallback::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoEventCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoEventCallback", 0, 0, 0)) SWIG_fail;
  result = (SoEventCallback *)new SoEventCallback();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEventCallback, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_setPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventCallback_setPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_setPath" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_setPath" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->setPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_getPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_getPath" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = (SoPath *)(arg1)->getPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_addEventCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  SoEventCallbackCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_addEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoEventCallback_addEventCallback" "', argument " "3"" of type '" "SoEventCallbackCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEventCallback_addEventCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->addEventCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_addEventCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  SoEventCallbackCB *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_addEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoEventCallback_addEventCallback" "', argument " "3"" of type '" "SoEventCallbackCB *""'"); 
    }
  }
  (arg1)->addEventCallback(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_removeEventCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  SoEventCallbackCB *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res4 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_removeEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoEventCallback_removeEventCallback" "', argument " "3"" of type '" "SoEventCallbackCB *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoEventCallback_removeEventCallback" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->removeEventCallback(SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_removeEventCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  SoEventCallbackCB *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_removeEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoEventCallback_removeEventCallback" "', argument " "3"" of type '" "SoEventCallbackCB *""'"); 
    }
  }
  (arg1)->removeEventCallback(SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_getAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoHandleEventAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_getAction" "', argument " "1"" of type '" "SoEventCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = (SoHandleEventAction *)((SoEventCallback const *)arg1)->getAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_getEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_getEvent" "', argument " "1"" of type '" "SoEventCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = (SoEvent *)((SoEventCallback const *)arg1)->getEvent();
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_getPickedPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_getPickedPoint" "', argument " "1"" of type '" "SoEventCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = (SoPickedPoint *)((SoEventCallback const *)arg1)->getPickedPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_setHandled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_setHandled" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  (arg1)->setHandled();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_isHandled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_isHandled" "', argument " "1"" of type '" "SoEventCallback const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  result = (SbBool)((SoEventCallback const *)arg1)->isHandled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_grabEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_grabEvents" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  (arg1)->grabEvents();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_releaseEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_releaseEvents" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  (arg1)->releaseEvents();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_addEventCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_addEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  arg4 = swig_obj[3];
  result = (PyObject *)SoEventCallback_addEventCallback__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_addEventCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_addEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_addEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  result = (PyObject *)SoEventCallback_addEventCallback__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_addEventCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEventCallback_addEventCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoEventCallback_addEventCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoEventCallback_addEventCallback__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoEventCallback_addEventCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyCallable_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SoEventCallback_addEventCallback__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEventCallback_addEventCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEventCallback::addEventCallback(SoType,SoEventCallbackCB *,void *)\n"
    "    SoEventCallback::addEventCallback(SoType,SoEventCallbackCB *)\n"
    "    SoEventCallback::addEventCallback(SoType,PyObject *,PyObject *)\n"
    "    SoEventCallback::addEventCallback(SoType,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_removeEventCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoEventCallback *arg1 = 0 ;
  SoType arg2 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventCallback_removeEventCallback" "', argument " "1"" of type '" "SoEventCallback *""'"); 
  }
  arg1 = reinterpret_cast< SoEventCallback * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventCallback_removeEventCallback" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  arg3 = swig_obj[2];
  SoEventCallback_removeEventCallback__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventCallback_removeEventCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoEventCallback_removeEventCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoEventCallback_removeEventCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoEventCallback_removeEventCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoEventCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SoType, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_void_p_SoEventCallback__void);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoEventCallback_removeEventCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoEventCallback_removeEventCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoEventCallback::removeEventCallback(SoType,SoEventCallbackCB *,void *)\n"
    "    SoEventCallback::removeEventCallback(SoType,SoEventCallbackCB *)\n"
    "    SoEventCallback::removeEventCallback(SoType,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoEventCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEventCallback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEventCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSelection_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelection_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSelection::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_getTypeId" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = ((SoSelection const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelection_initClass", 0, 0, 0)) SWIG_fail;
  SoSelection::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSelection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoSelection *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoSelection *)new SoSelection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSelection, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_policy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelection_policy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_policy_set" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_policy_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->policy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_policy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_policy_get" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = (SoSFEnum *)& ((arg1)->policy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSelection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoSelection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoSelection" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoSelection *)new SoSelection(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSelection, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSelection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoSelection", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoSelection__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoSelection__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoSelection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::SoSelection()\n"
    "    SoSelection::SoSelection(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_select__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_select" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_select" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->select((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_select__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_select" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_select" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->select(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_select(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_select", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_select__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_select__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_select'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::select(SoPath const *)\n"
    "    SoSelection::select(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_deselect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_deselect" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_deselect" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->deselect((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_deselect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_deselect" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSelection_deselect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->deselect(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_deselect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_deselect" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_deselect" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->deselect(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_deselect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_deselect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_deselect__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_deselect__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSelection_deselect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_deselect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::deselect(SoPath const *)\n"
    "    SoSelection::deselect(int const)\n"
    "    SoSelection::deselect(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_toggle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_toggle" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_toggle" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->toggle((SoPath const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_toggle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_toggle" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_toggle" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->toggle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_toggle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_toggle", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_toggle__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_toggle__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_toggle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::toggle(SoPath const *)\n"
    "    SoSelection::toggle(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_isSelected__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_isSelected" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_isSelected" "', argument " "2"" of type '" "SoPath const *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)((SoSelection const *)arg1)->isSelected((SoPath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_isSelected__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_isSelected" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSelection_isSelected" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbBool)((SoSelection const *)arg1)->isSelected(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_isSelected(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_isSelected", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_isSelected__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_isSelected__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_isSelected'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::isSelected(SoPath const *) const\n"
    "    SoSelection::isSelected(SoNode *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_deselectAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_deselectAll" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  (arg1)->deselectAll();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_getNumSelected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_getNumSelected" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = (int)((SoSelection const *)arg1)->getNumSelected();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_getList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_getList" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = (SoPathList *)((SoSelection const *)arg1)->getList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_getPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelection_getPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_getPath" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSelection_getPath" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoPath *)((SoSelection const *)arg1)->getPath(arg2);
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addSelectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addSelectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_addSelectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addSelectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addSelectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addSelectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  (arg1)->addSelectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeSelectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeSelectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_removeSelectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeSelectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeSelectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeSelectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  (arg1)->removeSelectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addDeselectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addDeselectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_addDeselectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addDeselectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addDeselectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addDeselectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  (arg1)->addDeselectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeDeselectionCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeDeselectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeDeselectionCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPathCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoPath__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "2"" of type '" "SoSelectionPathCB *""'"); 
    }
  }
  (arg1)->removeDeselectionCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addStartCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_addStartCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addStartCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addStartCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->addStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeStartCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_removeStartCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeStartCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeStartCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->removeStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addFinishCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_addFinishCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addFinishCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addFinishCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->addFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeFinishCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_removeFinishCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeFinishCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeFinishCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->removeFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPickCB *arg2 = 0 ;
  void *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_setPickFilterCallback" "', argument " "2"" of type '" "SoSelectionPickCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_setPickFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSelection_setPickFilterCallback" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  (arg1)->setPickFilterCallback(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPickCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_setPickFilterCallback" "', argument " "2"" of type '" "SoSelectionPickCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_setPickFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setPickFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionPickCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_setPickFilterCallback" "', argument " "2"" of type '" "SoSelectionPickCB *""'"); 
    }
  }
  (arg1)->setPickFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickMatching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSelection_setPickMatching", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickMatching" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSelection_setPickMatching" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setPickMatching(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_isPickMatching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_isPickMatching" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = (SbBool)((SoSelection const *)arg1)->isPickMatching();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_getPickMatching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_getPickMatching" "', argument " "1"" of type '" "SoSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  result = (SbBool)((SoSelection const *)arg1)->getPickMatching();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addChangeCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addChangeCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_addChangeCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addChangeCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addChangeCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_addChangeCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->addChangeCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeChangeCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeChangeCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSelection_removeChangeCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeChangeCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeChangeCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  SoSelectionClassCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSelection__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSelection_removeChangeCallback" "', argument " "2"" of type '" "SoSelectionClassCB *""'"); 
    }
  }
  (arg1)->removeChangeCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addSelectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_addSelectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addSelectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_addSelectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addSelectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_addSelectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_addSelectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_addSelectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_addSelectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_addSelectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_addSelectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::addSelectionCallback(SoSelectionPathCB *,void *)\n"
    "    SoSelection::addSelectionCallback(SoSelectionPathCB *)\n"
    "    SoSelection::addSelectionCallback(PyObject *,PyObject *)\n"
    "    SoSelection::addSelectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeSelectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_removeSelectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeSelectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeSelectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_removeSelectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeSelectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_removeSelectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_removeSelectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_removeSelectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_removeSelectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_removeSelectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_removeSelectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::removeSelectionCallback(SoSelectionPathCB *,void *)\n"
    "    SoSelection::removeSelectionCallback(SoSelectionPathCB *)\n"
    "    SoSelection::removeSelectionCallback(PyObject *,PyObject *)\n"
    "    SoSelection::removeSelectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_addDeselectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_addDeselectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addDeselectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_addDeselectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addDeselectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_addDeselectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_addDeselectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_addDeselectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_addDeselectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_addDeselectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_addDeselectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::addDeselectionCallback(SoSelectionPathCB *,void *)\n"
    "    SoSelection::addDeselectionCallback(SoSelectionPathCB *)\n"
    "    SoSelection::addDeselectionCallback(PyObject *,PyObject *)\n"
    "    SoSelection::addDeselectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeDeselectionCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_removeDeselectionCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeDeselectionCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeDeselectionCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_removeDeselectionCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeDeselectionCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_removeDeselectionCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_removeDeselectionCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_removeDeselectionCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoPath__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_removeDeselectionCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_removeDeselectionCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_removeDeselectionCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::removeDeselectionCallback(SoSelectionPathCB *,void *)\n"
    "    SoSelection::removeDeselectionCallback(SoSelectionPathCB *)\n"
    "    SoSelection::removeDeselectionCallback(PyObject *,PyObject *)\n"
    "    SoSelection::removeDeselectionCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_addStartCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_addStartCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addStartCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_addStartCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_addStartCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_addStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_addStartCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_addStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_addStartCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_addStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::addStartCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::addStartCallback(SoSelectionClassCB *)\n"
    "    SoSelection::addStartCallback(PyObject *,PyObject *)\n"
    "    SoSelection::addStartCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeStartCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_removeStartCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeStartCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeStartCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_removeStartCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_removeStartCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_removeStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_removeStartCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_removeStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_removeStartCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_removeStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::removeStartCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::removeStartCallback(SoSelectionClassCB *)\n"
    "    SoSelection::removeStartCallback(PyObject *,PyObject *)\n"
    "    SoSelection::removeStartCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_addFinishCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_addFinishCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addFinishCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_addFinishCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_addFinishCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_addFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_addFinishCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_addFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_addFinishCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_addFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::addFinishCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::addFinishCallback(SoSelectionClassCB *)\n"
    "    SoSelection::addFinishCallback(PyObject *,PyObject *)\n"
    "    SoSelection::addFinishCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeFinishCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_removeFinishCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeFinishCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeFinishCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_removeFinishCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_removeFinishCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_removeFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_removeFinishCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_removeFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_removeFinishCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_removeFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::removeFinishCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::removeFinishCallback(SoSelectionClassCB *)\n"
    "    SoSelection::removeFinishCallback(PyObject *,PyObject *)\n"
    "    SoSelection::removeFinishCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSelection_setPickFilterCallback" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  SoSelection_setPickFilterCallback__SWIG_3(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_setPickFilterCallback__SWIG_3(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_setPickFilterCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_setPickFilterCallback__SWIG_3(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_setPickFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_setPickFilterCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_setPickFilterCallback__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_setPickFilterCallback__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_setPickFilterCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_setPickFilterCallback__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSelection_setPickFilterCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSelection_setPickFilterCallback__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_setPickFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::setPickFilterCallback(SoSelectionPickCB *,void *,SbBool const)\n"
    "    SoSelection::setPickFilterCallback(SoSelectionPickCB *,void *)\n"
    "    SoSelection::setPickFilterCallback(SoSelectionPickCB *)\n"
    "    SoSelection::setPickFilterCallback(PyObject *,PyObject *,int)\n"
    "    SoSelection::setPickFilterCallback(PyObject *,PyObject *)\n"
    "    SoSelection::setPickFilterCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_addChangeCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_addChangeCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addChangeCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_addChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_addChangeCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_addChangeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_addChangeCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_addChangeCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_addChangeCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_addChangeCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_addChangeCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_addChangeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::addChangeCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::addChangeCallback(SoSelectionClassCB *)\n"
    "    SoSelection::addChangeCallback(PyObject *,PyObject *)\n"
    "    SoSelection::addChangeCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeChangeCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSelection_removeChangeCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeChangeCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSelection *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSelection_removeChangeCallback" "', argument " "1"" of type '" "SoSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoSelection * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSelection_removeChangeCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSelection_removeChangeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSelection_removeChangeCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSelection_removeChangeCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSelection_removeChangeCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSelection__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSelection_removeChangeCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSelection_removeChangeCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSelection_removeChangeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSelection::removeChangeCallback(SoSelectionClassCB *,void *)\n"
    "    SoSelection::removeChangeCallback(SoSelectionClassCB *)\n"
    "    SoSelection::removeChangeCallback(PyObject *,PyObject *)\n"
    "    SoSelection::removeChangeCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSelection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSelection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSelection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoExtSelection_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoExtSelection::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getTypeId" "', argument " "1"" of type '" "SoExtSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = ((SoExtSelection const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_initClass", 0, 0, 0)) SWIG_fail;
  SoExtSelection::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoExtSelection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoExtSelection", 0, 0, 0)) SWIG_fail;
  result = (SoExtSelection *)new SoExtSelection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoExtSelection, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_lassoType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoType_set" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_lassoType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->lassoType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoType_get" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SoSFEnum *)& ((arg1)->lassoType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoPolicy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_lassoPolicy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoPolicy_set" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_lassoPolicy_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->lassoPolicy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoPolicy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoPolicy_get" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SoSFEnum *)& ((arg1)->lassoPolicy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoMode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_lassoMode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoMode_set" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_lassoMode_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->lassoMode = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_lassoMode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_lassoMode_get" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SoSFEnum *)& ((arg1)->lassoMode);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_useOverlay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_useOverlay" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoExtSelection_useOverlay" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->useOverlay(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_useOverlay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_useOverlay" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  (arg1)->useOverlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_useOverlay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_useOverlay", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoExtSelection_useOverlay__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoExtSelection_useOverlay__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_useOverlay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::useOverlay(SbBool)\n"
    "    SoExtSelection::useOverlay()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_isUsingOverlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_isUsingOverlay" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SbBool)(arg1)->isUsingOverlay();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getOverlaySceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSeparator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getOverlaySceneGraph" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SoSeparator *)(arg1)->getOverlaySceneGraph();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSeparator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setOverlayLassoColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_setOverlayLassoColorIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setOverlayLassoColorIndex" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoExtSelection_setOverlayLassoColorIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setOverlayLassoColorIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getOverlayLassoColorIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getOverlayLassoColorIndex" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (int)(arg1)->getOverlayLassoColorIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_setLassoColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLassoColor" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_setLassoColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoExtSelection_setLassoColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setLassoColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getLassoColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getLassoColor" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SbColor *) &(arg1)->getLassoColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_setLassoWidth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLassoWidth" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoExtSelection_setLassoWidth" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setLassoWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getLassoWidth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getLassoWidth" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (float)(arg1)->getLassoWidth();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setOverlayLassoPattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_setOverlayLassoPattern", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setOverlayLassoPattern" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoExtSelection_setOverlayLassoPattern" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setOverlayLassoPattern(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getOverlayLassoPattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getOverlayLassoPattern" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (unsigned short)(arg1)->getOverlayLassoPattern();
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_animateOverlayLasso__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_animateOverlayLasso" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoExtSelection_animateOverlayLasso" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->animateOverlayLasso(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_animateOverlayLasso__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_animateOverlayLasso" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  (arg1)->animateOverlayLasso();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_animateOverlayLasso(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_animateOverlayLasso", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoExtSelection_animateOverlayLasso__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoExtSelection_animateOverlayLasso__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_animateOverlayLasso'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::animateOverlayLasso(SbBool const)\n"
    "    SoExtSelection::animateOverlayLasso()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_isOverlayLassoAnimated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_isOverlayLassoAnimated" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SbBool)(arg1)->isOverlayLassoAnimated();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_handleEvent" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_GLRenderBelowPath" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_select__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  SbVec2f *arg4 = 0 ;
  SbViewportRegion *arg5 = 0 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_select" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_select" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoExtSelection_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec2f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoExtSelection_select" "', argument " "4"" of type '" "SbVec2f *""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoExtSelection_select" "', argument " "5"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoExtSelection_select" "', argument " "5"" of type '" "SbViewportRegion const &""'"); 
  }
  arg5 = reinterpret_cast< SbViewportRegion * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoExtSelection_select" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->select(arg2,arg3,arg4,(SbViewportRegion const &)*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_select__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  SbVec3f *arg4 = 0 ;
  SbViewportRegion *arg5 = 0 ;
  SbBool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_select" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_select" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoExtSelection_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SbVec3f, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoExtSelection_select" "', argument " "4"" of type '" "SbVec3f *""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoExtSelection_select" "', argument " "5"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoExtSelection_select" "', argument " "5"" of type '" "SbViewportRegion const &""'"); 
  }
  arg5 = reinterpret_cast< SbViewportRegion * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SoExtSelection_select" "', argument " "6"" of type '" "SbBool""'");
  } 
  arg6 = static_cast< SbBool >(val6);
  (arg1)->select(arg2,arg3,arg4,(SbViewportRegion const &)*arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_select(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_select", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec2f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoExtSelection_select__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SoExtSelection_select__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_select'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::select(SoNode *,int,SbVec2f *,SbViewportRegion const &,SbBool)\n"
    "    SoExtSelection::select(SoNode *,int,SbVec3f *,SbViewportRegion const &,SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getLassoCoordsDC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_getLassoCoordsDC", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getLassoCoordsDC" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_getLassoCoordsDC" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoExtSelection_getLassoCoordsDC" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SbVec2s *)(arg1)->getLassoCoordsDC(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getLassoCoordsWC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoExtSelection_getLassoCoordsWC", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getLassoCoordsWC" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoExtSelection_getLassoCoordsWC" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoExtSelection_getLassoCoordsWC" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (SbVec3f *)(arg1)->getLassoCoordsWC(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_getSelectionPathList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_getSelectionPathList" "', argument " "1"" of type '" "SoExtSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SoPathList *) &((SoExtSelection const *)arg1)->getSelectionPathList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoLassoSelectionFilterCB *arg2 = 0 ;
  void *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "2"" of type '" "SoLassoSelectionFilterCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  (arg1)->setLassoFilterCallback(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoLassoSelectionFilterCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "2"" of type '" "SoLassoSelectionFilterCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setLassoFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoFilterCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoLassoSelectionFilterCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setLassoFilterCallback" "', argument " "2"" of type '" "SoLassoSelectionFilterCB *""'"); 
    }
  }
  (arg1)->setLassoFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLassoFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_setLassoFilterCallback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoExtSelection_setLassoFilterCallback__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoExtSelection_setLassoFilterCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoExtSelection_setLassoFilterCallback__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_setLassoFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::setLassoFilterCallback(SoLassoSelectionFilterCB *,void *,SbBool const)\n"
    "    SoExtSelection::setLassoFilterCallback(SoLassoSelectionFilterCB *,void *)\n"
    "    SoExtSelection::setLassoFilterCallback(SoLassoSelectionFilterCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setTriangleFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionTriangleCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setTriangleFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setTriangleFilterCallback" "', argument " "2"" of type '" "SoExtSelectionTriangleCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoExtSelection_setTriangleFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setTriangleFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setTriangleFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionTriangleCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setTriangleFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setTriangleFilterCallback" "', argument " "2"" of type '" "SoExtSelectionTriangleCB *""'"); 
    }
  }
  (arg1)->setTriangleFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setTriangleFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_setTriangleFilterCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoExtSelection_setTriangleFilterCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoExtSelection_setTriangleFilterCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_setTriangleFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::setTriangleFilterCallback(SoExtSelectionTriangleCB *,void *)\n"
    "    SoExtSelection::setTriangleFilterCallback(SoExtSelectionTriangleCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLineSegmentFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionLineSegmentCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLineSegmentFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setLineSegmentFilterCallback" "', argument " "2"" of type '" "SoExtSelectionLineSegmentCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoExtSelection_setLineSegmentFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setLineSegmentFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLineSegmentFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionLineSegmentCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setLineSegmentFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setLineSegmentFilterCallback" "', argument " "2"" of type '" "SoExtSelectionLineSegmentCB *""'"); 
    }
  }
  (arg1)->setLineSegmentFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setLineSegmentFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_setLineSegmentFilterCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoExtSelection_setLineSegmentFilterCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoExtSelection_setLineSegmentFilterCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_setLineSegmentFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::setLineSegmentFilterCallback(SoExtSelectionLineSegmentCB *,void *)\n"
    "    SoExtSelection::setLineSegmentFilterCallback(SoExtSelectionLineSegmentCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setPointFilterCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionPointCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setPointFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setPointFilterCallback" "', argument " "2"" of type '" "SoExtSelectionPointCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoExtSelection_setPointFilterCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setPointFilterCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setPointFilterCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  SoExtSelectionPointCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_setPointFilterCallback" "', argument " "1"" of type '" "SoExtSelection *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoExtSelection_setPointFilterCallback" "', argument " "2"" of type '" "SoExtSelectionPointCB *""'"); 
    }
  }
  (arg1)->setPointFilterCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_setPointFilterCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoExtSelection_setPointFilterCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoExtSelection_setPointFilterCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoExtSelection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoExtSelection_setPointFilterCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoExtSelection_setPointFilterCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoExtSelection::setPointFilterCallback(SoExtSelectionPointCB *,void *)\n"
    "    SoExtSelection::setPointFilterCallback(SoExtSelectionPointCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoExtSelection_wasShiftDown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoExtSelection *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoExtSelection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoExtSelection_wasShiftDown" "', argument " "1"" of type '" "SoExtSelection const *""'"); 
  }
  arg1 = reinterpret_cast< SoExtSelection * >(argp1);
  result = (SbBool)((SoExtSelection const *)arg1)->wasShiftDown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoExtSelection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoExtSelection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoExtSelection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVertexProperty_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexProperty::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_getTypeId" "', argument " "1"" of type '" "SoVertexProperty const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = ((SoVertexProperty const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexProperty::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVertexProperty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVertexProperty", 0, 0, 0)) SWIG_fail;
  result = (SoVertexProperty *)new SoVertexProperty();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVertexProperty, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_vertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_vertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_vertex_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_vertex_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->vertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_vertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_vertex_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->vertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_texCoord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_texCoord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_texCoord_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_texCoord_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->texCoord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_texCoord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_texCoord_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->texCoord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_texCoord3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_texCoord3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_texCoord3_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_texCoord3_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->texCoord3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_texCoord3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_texCoord3_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->texCoord3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_normal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_normal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_normal_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_normal_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->normal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_normal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_normal_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->normal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_normalBinding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_normalBinding_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_normalBinding_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_normalBinding_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->normalBinding = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_normalBinding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_normalBinding_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoSFEnum *)& ((arg1)->normalBinding);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_orderedRGBA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_orderedRGBA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_orderedRGBA_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_orderedRGBA_set" "', argument " "2"" of type '" "SoMFUInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFUInt32 * >(argp2);
  if (arg1) (arg1)->orderedRGBA = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_orderedRGBA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFUInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_orderedRGBA_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFUInt32 *)& ((arg1)->orderedRGBA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_materialBinding_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_materialBinding_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_materialBinding_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_materialBinding_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->materialBinding = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_materialBinding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_materialBinding_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoSFEnum *)& ((arg1)->materialBinding);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_textureUnit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_textureUnit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_textureUnit_set" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_textureUnit_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->textureUnit = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_textureUnit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_textureUnit_get" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->textureUnit);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_doAction" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_GLRender" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_getBoundingBox" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_callback" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_pick" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexProperty_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexProperty *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexProperty_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexProperty, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexProperty_getPrimitiveCount" "', argument " "1"" of type '" "SoVertexProperty *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexProperty * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexProperty_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexProperty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexProperty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVertexProperty_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVertexShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_getTypeId" "', argument " "1"" of type '" "SoVertexShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  result = ((SoVertexShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShape_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_vertexProperty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShape_vertexProperty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_vertexProperty_set" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexShape_vertexProperty_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->vertexProperty = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_vertexProperty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_vertexProperty_get" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->vertexProperty);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShape_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_notify" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexShape_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_generateDefaultNormals__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_generateDefaultNormals__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalCache *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVertexShape_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalCache *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalCache * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_generateDefaultNormals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVertexShape_generateDefaultNormals", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVertexShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalBundle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVertexShape_generateDefaultNormals__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVertexShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalCache, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVertexShape_generateDefaultNormals__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVertexShape_generateDefaultNormals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVertexShape::generateDefaultNormals(SoState *,SoNormalBundle *)\n"
    "    SoVertexShape::generateDefaultNormals(SoState *,SoNormalCache *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVertexShape_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShape *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShape_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShape_write" "', argument " "1"" of type '" "SoVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexShape_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoNonIndexedShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNonIndexedShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNonIndexedShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNonIndexedShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNonIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNonIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNonIndexedShape_getTypeId" "', argument " "1"" of type '" "SoNonIndexedShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoNonIndexedShape * >(argp1);
  result = ((SoNonIndexedShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNonIndexedShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNonIndexedShape_initClass", 0, 0, 0)) SWIG_fail;
  SoNonIndexedShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNonIndexedShape_startIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNonIndexedShape *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNonIndexedShape_startIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNonIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNonIndexedShape_startIndex_set" "', argument " "1"" of type '" "SoNonIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoNonIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNonIndexedShape_startIndex_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->startIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNonIndexedShape_startIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNonIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNonIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNonIndexedShape_startIndex_get" "', argument " "1"" of type '" "SoNonIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoNonIndexedShape * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->startIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNonIndexedShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNonIndexedShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoFaceSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFaceSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_getTypeId" "', argument " "1"" of type '" "SoFaceSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  result = ((SoFaceSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_initClass", 0, 0, 0)) SWIG_fail;
  SoFaceSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFaceSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFaceSet", 0, 0, 0)) SWIG_fail;
  result = (SoFaceSet *)new SoFaceSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFaceSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_numVertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_numVertices_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_numVertices_set" "', argument " "1"" of type '" "SoFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFaceSet_numVertices_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->numVertices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_numVertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_numVertices_get" "', argument " "1"" of type '" "SoFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->numVertices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_GLRender" "', argument " "1"" of type '" "SoFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFaceSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_generateDefaultNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_generateDefaultNormals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_generateDefaultNormals" "', argument " "1"" of type '" "SoFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFaceSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoFaceSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFaceSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFaceSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFaceSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFaceSet_getPrimitiveCount" "', argument " "1"" of type '" "SoFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFaceSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFaceSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFaceSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFaceSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFile_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFile::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getTypeId" "', argument " "1"" of type '" "SoFile const *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  result = ((SoFile const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_initClass", 0, 0, 0)) SWIG_fail;
  SoFile::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFile", 0, 0, 0)) SWIG_fail;
  result = (SoFile *)new SoFile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFile, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_name_set" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_name_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_name_get" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  result = (SoSFString *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_doAction" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_callback" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_GLRender" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getBoundingBox" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getMatrix" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_handleEvent" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_pick" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getPrimitiveCount" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_audioRender" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_search" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_copyChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGroup *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_copyChildren" "', argument " "1"" of type '" "SoFile const *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  result = (SoGroup *)((SoFile const *)arg1)->copyChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGroup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getChildren" "', argument " "1"" of type '" "SoFile const *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  result = (SoChildList *)((SoFile const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_copyContents" "', argument " "1"" of type '" "SoFile *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFile_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoFile_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getFullName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFile_getFullName" "', argument " "1"" of type '" "SoFile const *""'"); 
  }
  arg1 = reinterpret_cast< SoFile * >(argp1);
  result = (SbString *) &((SoFile const *)arg1)->getFullName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_setSearchOK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoFile_setSearchOK" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoFile::setSearchOK(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFile_getSearchOK(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFile_getSearchOK", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoFile::getSearchOK();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFont_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFont::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_getTypeId" "', argument " "1"" of type '" "SoFont const *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  result = ((SoFont const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_initClass", 0, 0, 0)) SWIG_fail;
  SoFont::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFont(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFont", 0, 0, 0)) SWIG_fail;
  result = (SoFont *)new SoFont();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFont, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_name_set" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_name_set" "', argument " "2"" of type '" "SoSFName *""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_name_get" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  result = (SoSFName *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_size_set" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_size_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_size_get" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  result = (SoSFFloat *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_doAction" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_getBoundingBox" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_GLRender" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_callback" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_pick" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFont_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFont *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFont_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFont, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFont_getPrimitiveCount" "', argument " "1"" of type '" "SoFont *""'"); 
  }
  arg1 = reinterpret_cast< SoFont * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFont_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFont_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFont, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFont_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFontStyle_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFontStyle::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_getTypeId" "', argument " "1"" of type '" "SoFontStyle const *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  result = ((SoFontStyle const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_initClass", 0, 0, 0)) SWIG_fail;
  SoFontStyle::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFontStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFontStyle", 0, 0, 0)) SWIG_fail;
  result = (SoFontStyle *)new SoFontStyle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFontStyle, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_family_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_family_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_family_set" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_family_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->family = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_family_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_family_get" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  result = (SoSFEnum *)& ((arg1)->family);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_style_set" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_style_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_style_get" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_getFontName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_getFontName" "', argument " "1"" of type '" "SoFontStyle const *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  result = ((SoFontStyle const *)arg1)->getFontName();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_doAction" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_getBoundingBox" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_GLRender" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_callback" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_pick" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFontStyle_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFontStyle *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFontStyle_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFontStyle_getPrimitiveCount" "', argument " "1"" of type '" "SoFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFontStyle_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFontStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFontStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFontStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGeoCoordinate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGeoCoordinate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_getTypeId" "', argument " "1"" of type '" "SoGeoCoordinate const *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  result = ((SoGeoCoordinate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_initClass", 0, 0, 0)) SWIG_fail;
  SoGeoCoordinate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGeoCoordinate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGeoCoordinate", 0, 0, 0)) SWIG_fail;
  result = (SoGeoCoordinate *)new SoGeoCoordinate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGeoCoordinate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoMFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_point_set" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_point_set" "', argument " "2"" of type '" "SoMFVec3d *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3d * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_point_get" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  result = (SoMFVec3d *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_geoSystem_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_geoSystem_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_geoSystem_set" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_geoSystem_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->geoSystem = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_geoSystem_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_geoSystem_get" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  result = (SoMFString *)& ((arg1)->geoSystem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_doAction" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_callback" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_GLRender" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_getBoundingBox" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_pick" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoCoordinate_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoCoordinate *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoCoordinate_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoCoordinate_getPrimitiveCount" "', argument " "1"" of type '" "SoGeoCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoCoordinate_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGeoCoordinate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGeoCoordinate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGeoCoordinate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGeoLocation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGeoLocation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_getTypeId" "', argument " "1"" of type '" "SoGeoLocation const *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  result = ((SoGeoLocation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_initClass", 0, 0, 0)) SWIG_fail;
  SoGeoLocation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGeoLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGeoLocation", 0, 0, 0)) SWIG_fail;
  result = (SoGeoLocation *)new SoGeoLocation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGeoLocation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_geoCoords_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoSFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_geoCoords_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_geoCoords_set" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_geoCoords_set" "', argument " "2"" of type '" "SoSFVec3d *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3d * >(argp2);
  if (arg1) (arg1)->geoCoords = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_geoCoords_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_geoCoords_get" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  result = (SoSFVec3d *)& ((arg1)->geoCoords);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_geoSystem_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_geoSystem_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_geoSystem_set" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_geoSystem_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->geoSystem = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_geoSystem_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_geoSystem_get" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  result = (SoMFString *)& ((arg1)->geoSystem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_doAction" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_callback" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_GLRender" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_getBoundingBox" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_getMatrix" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_pick" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoLocation_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoLocation *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoLocation_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoLocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoLocation_getPrimitiveCount" "', argument " "1"" of type '" "SoGeoLocation *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoLocation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoLocation_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGeoLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGeoLocation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGeoLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGeoOrigin_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGeoOrigin::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_getTypeId" "', argument " "1"" of type '" "SoGeoOrigin const *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  result = ((SoGeoOrigin const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_initClass", 0, 0, 0)) SWIG_fail;
  SoGeoOrigin::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGeoOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGeoOrigin", 0, 0, 0)) SWIG_fail;
  result = (SoGeoOrigin *)new SoGeoOrigin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGeoOrigin, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_geoCoords_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoSFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_geoCoords_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_geoCoords_set" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_geoCoords_set" "', argument " "2"" of type '" "SoSFVec3d *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3d * >(argp2);
  if (arg1) (arg1)->geoCoords = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_geoCoords_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_geoCoords_get" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  result = (SoSFVec3d *)& ((arg1)->geoCoords);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_geoSystem_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_geoSystem_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_geoSystem_set" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_geoSystem_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->geoSystem = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_geoSystem_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_geoSystem_get" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  result = (SoMFString *)& ((arg1)->geoSystem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_doAction" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_callback" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_GLRender" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_getBoundingBox" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_getMatrix" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_pick" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoOrigin_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoOrigin *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoOrigin_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoOrigin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoOrigin_getPrimitiveCount" "', argument " "1"" of type '" "SoGeoOrigin *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoOrigin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoOrigin_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGeoOrigin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGeoOrigin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGeoOrigin_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoGeoSeparator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoGeoSeparator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_getTypeId" "', argument " "1"" of type '" "SoGeoSeparator const *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  result = ((SoGeoSeparator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_initClass", 0, 0, 0)) SWIG_fail;
  SoGeoSeparator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoGeoSeparator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoGeoSeparator", 0, 0, 0)) SWIG_fail;
  result = (SoGeoSeparator *)new SoGeoSeparator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGeoSeparator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_geoCoords_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoSFVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_geoCoords_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_geoCoords_set" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_geoCoords_set" "', argument " "2"" of type '" "SoSFVec3d *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3d * >(argp2);
  if (arg1) (arg1)->geoCoords = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_geoCoords_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_geoCoords_get" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  result = (SoSFVec3d *)& ((arg1)->geoCoords);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_geoSystem_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_geoSystem_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_geoSystem_set" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_geoSystem_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->geoSystem = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_geoSystem_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_geoSystem_get" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  result = (SoMFString *)& ((arg1)->geoSystem);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_callback" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_GLRenderBelowPath" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_GLRenderInPath" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_getBoundingBox" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_getMatrix" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_rayPick" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoGeoSeparator_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGeoSeparator *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoGeoSeparator_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGeoSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoGeoSeparator_getPrimitiveCount" "', argument " "1"" of type '" "SoGeoSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoGeoSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoGeoSeparator_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoGeoSeparator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoGeoSeparator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoGeoSeparator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_getTypeId" "', argument " "1"" of type '" "SoIndexedShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  result = ((SoIndexedShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_coordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_coordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_coordIndex_set" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedShape_coordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->coordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_coordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_coordIndex_get" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->coordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_materialIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_materialIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_materialIndex_set" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedShape_materialIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->materialIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_materialIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_materialIndex_get" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->materialIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_normalIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_normalIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_normalIndex_set" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedShape_normalIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->normalIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_normalIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_normalIndex_get" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->normalIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_textureCoordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedShape_textureCoordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_textureCoordIndex_set" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedShape_textureCoordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->textureCoordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedShape_textureCoordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedShape_textureCoordIndex_get" "', argument " "1"" of type '" "SoIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->textureCoordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedFaceSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedFaceSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedFaceSet_getTypeId" "', argument " "1"" of type '" "SoIndexedFaceSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedFaceSet * >(argp1);
  result = ((SoIndexedFaceSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedFaceSet_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedFaceSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedFaceSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedFaceSet", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedFaceSet *)new SoIndexedFaceSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedFaceSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedFaceSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedFaceSet_GLRender" "', argument " "1"" of type '" "SoIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedFaceSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedFaceSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedFaceSet_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedFaceSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_generateDefaultNormals__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "1"" of type '" "SoIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_generateDefaultNormals__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoIndexedFaceSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalCache *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "1"" of type '" "SoIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIndexedFaceSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalCache *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalCache * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedFaceSet_generateDefaultNormals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoIndexedFaceSet_generateDefaultNormals", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIndexedFaceSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalBundle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoIndexedFaceSet_generateDefaultNormals__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoIndexedFaceSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalCache, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoIndexedFaceSet_generateDefaultNormals__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoIndexedFaceSet_generateDefaultNormals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoIndexedFaceSet::generateDefaultNormals(SoState *,SoNormalBundle *)\n"
    "    SoIndexedFaceSet::generateDefaultNormals(SoState *,SoNormalCache *)\n");
  return 0;
}


SWIGINTERN PyObject *SoIndexedFaceSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedFaceSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedFaceSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedLineSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedLineSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedLineSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedLineSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedLineSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedLineSet_getTypeId" "', argument " "1"" of type '" "SoIndexedLineSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedLineSet * >(argp1);
  result = ((SoIndexedLineSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedLineSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedLineSet_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedLineSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedLineSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedLineSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedLineSet", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedLineSet *)new SoIndexedLineSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedLineSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedLineSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedLineSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedLineSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedLineSet_GLRender" "', argument " "1"" of type '" "SoIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedLineSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedLineSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedLineSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedLineSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedLineSet_getBoundingBox" "', argument " "1"" of type '" "SoIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedLineSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedLineSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedLineSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedLineSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedLineSet_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedLineSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedLineSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedLineSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedLineSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedNurbsCurve::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_getTypeId" "', argument " "1"" of type '" "SoIndexedNurbsCurve const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  result = ((SoIndexedNurbsCurve const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedNurbsCurve::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedNurbsCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedNurbsCurve", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedNurbsCurve *)new SoIndexedNurbsCurve();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedNurbsCurve, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_numControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_numControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_numControlPoints_set" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_numControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_numControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_numControlPoints_get" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_coordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_coordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_coordIndex_set" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_coordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->coordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_coordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_coordIndex_get" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->coordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_knotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_knotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_knotVector_set" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_knotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->knotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_knotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_knotVector_get" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  result = (SoMFFloat *)& ((arg1)->knotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_GLRender" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_rayPick" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_getBoundingBox" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsCurve_sendPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsCurve *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SoPrimitiveVertex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsCurve_sendPrimitive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsCurve_sendPrimitive" "', argument " "1"" of type '" "SoIndexedNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsCurve_sendPrimitive" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIndexedNurbsCurve_sendPrimitive" "', argument " "3"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  (arg1)->sendPrimitive(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedNurbsCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedNurbsCurve, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedNurbsCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedNurbsSurface::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_getTypeId" "', argument " "1"" of type '" "SoIndexedNurbsSurface const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = ((SoIndexedNurbsSurface const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedNurbsSurface::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedNurbsSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedNurbsSurface", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedNurbsSurface *)new SoIndexedNurbsSurface();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedNurbsSurface, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numUControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_numUControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numUControlPoints_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_numUControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numUControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numUControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numUControlPoints_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numUControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numVControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_numVControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numVControlPoints_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_numVControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numVControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numVControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numVControlPoints_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numVControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_coordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_coordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_coordIndex_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_coordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->coordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_coordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_coordIndex_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->coordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_uKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_uKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_uKnotVector_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_uKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->uKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_uKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_uKnotVector_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->uKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_vKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_vKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_vKnotVector_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_vKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->vKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_vKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_vKnotVector_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->vKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numSControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_numSControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numSControlPoints_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_numSControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numSControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numSControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numSControlPoints_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numSControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numTControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_numTControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numTControlPoints_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_numTControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numTControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_numTControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_numTControlPoints_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numTControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_textureCoordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_textureCoordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_textureCoordIndex_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_textureCoordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->textureCoordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_textureCoordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_textureCoordIndex_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->textureCoordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_sKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_sKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_sKnotVector_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_sKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->sKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_sKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_sKnotVector_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->sKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_tKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_tKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_tKnotVector_set" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_tKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->tKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_tKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_tKnotVector_get" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->tKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_GLRender" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_rayPick" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedNurbsSurface_sendPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedNurbsSurface *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SoPrimitiveVertex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedNurbsSurface_sendPrimitive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedNurbsSurface_sendPrimitive" "', argument " "1"" of type '" "SoIndexedNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedNurbsSurface_sendPrimitive" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIndexedNurbsSurface_sendPrimitive" "', argument " "3"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  (arg1)->sendPrimitive(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedNurbsSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedNurbsSurface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedNurbsSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedTriangleStripSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedTriangleStripSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedTriangleStripSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedTriangleStripSet_getTypeId" "', argument " "1"" of type '" "SoIndexedTriangleStripSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedTriangleStripSet * >(argp1);
  result = ((SoIndexedTriangleStripSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedTriangleStripSet_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedTriangleStripSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedTriangleStripSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedTriangleStripSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedTriangleStripSet", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedTriangleStripSet *)new SoIndexedTriangleStripSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedTriangleStripSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedTriangleStripSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedTriangleStripSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedTriangleStripSet_GLRender" "', argument " "1"" of type '" "SoIndexedTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedTriangleStripSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedTriangleStripSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedTriangleStripSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedTriangleStripSet_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedTriangleStripSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedTriangleStripSet_generateDefaultNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedTriangleStripSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedTriangleStripSet_generateDefaultNormals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedTriangleStripSet_generateDefaultNormals" "', argument " "1"" of type '" "SoIndexedTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedTriangleStripSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoIndexedTriangleStripSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedTriangleStripSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedTriangleStripSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedTriangleStripSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInfo_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInfo_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoInfo::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInfo_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInfo_getTypeId" "', argument " "1"" of type '" "SoInfo const *""'"); 
  }
  arg1 = reinterpret_cast< SoInfo * >(argp1);
  result = ((SoInfo const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInfo_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInfo_initClass", 0, 0, 0)) SWIG_fail;
  SoInfo::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInfo", 0, 0, 0)) SWIG_fail;
  result = (SoInfo *)new SoInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInfo, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInfo_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInfo *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInfo_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInfo_string_set" "', argument " "1"" of type '" "SoInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoInfo_string_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->string = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoInfo_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoInfo_string_get" "', argument " "1"" of type '" "SoInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoInfo * >(argp1);
  result = (SoSFString *)& ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLabel_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLabel_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLabel::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLabel_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLabel_getTypeId" "', argument " "1"" of type '" "SoLabel const *""'"); 
  }
  arg1 = reinterpret_cast< SoLabel * >(argp1);
  result = ((SoLabel const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLabel_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLabel_initClass", 0, 0, 0)) SWIG_fail;
  SoLabel::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLabel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLabel *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLabel", 0, 0, 0)) SWIG_fail;
  result = (SoLabel *)new SoLabel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLabel, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLabel_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLabel *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLabel_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLabel_label_set" "', argument " "1"" of type '" "SoLabel *""'"); 
  }
  arg1 = reinterpret_cast< SoLabel * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLabel_label_set" "', argument " "2"" of type '" "SoSFName *""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  if (arg1) (arg1)->label = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLabel_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLabel *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLabel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLabel_label_get" "', argument " "1"" of type '" "SoLabel *""'"); 
  }
  arg1 = reinterpret_cast< SoLabel * >(argp1);
  result = (SoSFName *)& ((arg1)->label);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLabel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLabel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLabel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLevelOfDetail_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLevelOfDetail::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_getTypeId" "', argument " "1"" of type '" "SoLevelOfDetail const *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  result = ((SoLevelOfDetail const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_initClass", 0, 0, 0)) SWIG_fail;
  SoLevelOfDetail::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLevelOfDetail__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoLevelOfDetail *)new SoLevelOfDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLevelOfDetail, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLevelOfDetail__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoLevelOfDetail *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoLevelOfDetail" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoLevelOfDetail *)new SoLevelOfDetail(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLevelOfDetail, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLevelOfDetail(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoLevelOfDetail", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoLevelOfDetail__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoLevelOfDetail__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoLevelOfDetail'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLevelOfDetail::SoLevelOfDetail()\n"
    "    SoLevelOfDetail::SoLevelOfDetail(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_screenArea_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_screenArea_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_screenArea_set" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_screenArea_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->screenArea = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_screenArea_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_screenArea_get" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  result = (SoMFFloat *)& ((arg1)->screenArea);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_doAction" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_callback" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_GLRender" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_rayPick" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_getBoundingBox" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_audioRender" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLevelOfDetail_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLevelOfDetail *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLevelOfDetail_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLevelOfDetail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLevelOfDetail_notify" "', argument " "1"" of type '" "SoLevelOfDetail *""'"); 
  }
  arg1 = reinterpret_cast< SoLevelOfDetail * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLevelOfDetail_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLevelOfDetail_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLevelOfDetail, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLevelOfDetail_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoProfile_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProfile::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_getTypeId" "', argument " "1"" of type '" "SoProfile const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  result = ((SoProfile const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_initClass", 0, 0, 0)) SWIG_fail;
  SoProfile::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_index_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_index_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_index_set" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_index_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->index = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_index_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_index_get" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->index);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_linkage_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_linkage_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_linkage_set" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_linkage_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->linkage = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_linkage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_linkage_get" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  result = (SoSFEnum *)& ((arg1)->linkage);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_doAction" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_callback" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_GLRender" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_getBoundingBox" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_pick" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_getPrimitiveCount" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_getTrimCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  float **arg4 = 0 ;
  int *arg5 = 0 ;
  int32_t *arg6 = 0 ;
  float **arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_getTrimCurve", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_getTrimCurve" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_getTrimCurve" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  arg4 = reinterpret_cast< float ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  arg6 = reinterpret_cast< int32_t * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  arg7 = reinterpret_cast< float ** >(argp7);
  (arg1)->getTrimCurve(arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfile_getVertices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  SbVec2f **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfile_getVertices", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfile_getVertices" "', argument " "1"" of type '" "SoProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfile_getVertices" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f ** >(argp4);
  (arg1)->getVertices(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProfile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProfile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoLinearProfile_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinearProfile_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLinearProfile::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinearProfile_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLinearProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLinearProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinearProfile_getTypeId" "', argument " "1"" of type '" "SoLinearProfile const *""'"); 
  }
  arg1 = reinterpret_cast< SoLinearProfile * >(argp1);
  result = ((SoLinearProfile const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinearProfile_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinearProfile_initClass", 0, 0, 0)) SWIG_fail;
  SoLinearProfile::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLinearProfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLinearProfile *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLinearProfile", 0, 0, 0)) SWIG_fail;
  result = (SoLinearProfile *)new SoLinearProfile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLinearProfile, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinearProfile_getTrimCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLinearProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  float **arg4 = 0 ;
  int *arg5 = 0 ;
  int32_t *arg6 = 0 ;
  float **arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinearProfile_getTrimCurve", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLinearProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "1"" of type '" "SoLinearProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoLinearProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  arg4 = reinterpret_cast< float ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  arg6 = reinterpret_cast< int32_t * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoLinearProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  arg7 = reinterpret_cast< float ** >(argp7);
  (arg1)->getTrimCurve(arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLinearProfile_getVertices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLinearProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  SbVec2f **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLinearProfile_getVertices", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLinearProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLinearProfile_getVertices" "', argument " "1"" of type '" "SoLinearProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoLinearProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLinearProfile_getVertices" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoLinearProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoLinearProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoLinearProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f ** >(argp4);
  (arg1)->getVertices(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLinearProfile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLinearProfile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLinearProfile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLineSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLineSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_getTypeId" "', argument " "1"" of type '" "SoLineSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  result = ((SoLineSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_initClass", 0, 0, 0)) SWIG_fail;
  SoLineSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLineSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLineSet", 0, 0, 0)) SWIG_fail;
  result = (SoLineSet *)new SoLineSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLineSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_numVertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_numVertices_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_numVertices_set" "', argument " "1"" of type '" "SoLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineSet_numVertices_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->numVertices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_numVertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_numVertices_get" "', argument " "1"" of type '" "SoLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->numVertices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_GLRender" "', argument " "1"" of type '" "SoLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_getBoundingBox" "', argument " "1"" of type '" "SoLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLineSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLineSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLineSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLineSet_getPrimitiveCount" "', argument " "1"" of type '" "SoLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLineSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLineSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLineSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLineSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoListener_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoListener::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_getTypeId" "', argument " "1"" of type '" "SoListener const *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = ((SoListener const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_initClass", 0, 0, 0)) SWIG_fail;
  SoListener::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoListener", 0, 0, 0)) SWIG_fail;
  result = (SoListener *)new SoListener();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoListener, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_position_set" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListener_position_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_position_get" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_orientation_set" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListener_orientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_orientation_get" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = (SoSFRotation *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_gain_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_gain_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_gain_set" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListener_gain_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->gain = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_gain_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_gain_get" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = (SoSFFloat *)& ((arg1)->gain);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_dopplerVelocity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_dopplerVelocity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_dopplerVelocity_set" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListener_dopplerVelocity_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->dopplerVelocity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_dopplerVelocity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_dopplerVelocity_get" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->dopplerVelocity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_dopplerFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoListener_dopplerFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_dopplerFactor_set" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoListener_dopplerFactor_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->dopplerFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoListener_dopplerFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoListener *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoListener_dopplerFactor_get" "', argument " "1"" of type '" "SoListener *""'"); 
  }
  arg1 = reinterpret_cast< SoListener * >(argp1);
  result = (SoSFFloat *)& ((arg1)->dopplerFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoListener_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoListener, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoListener_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLocateHighlight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLocateHighlight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_getTypeId" "', argument " "1"" of type '" "SoLocateHighlight const *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  result = ((SoLocateHighlight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_initClass", 0, 0, 0)) SWIG_fail;
  SoLocateHighlight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLocateHighlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoLocateHighlight", 0, 0, 0)) SWIG_fail;
  result = (SoLocateHighlight *)new SoLocateHighlight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLocateHighlight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_color_set" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_color_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_color_get" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  result = (SoSFColor *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_style_set" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_style_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_style_get" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  result = (SoSFEnum *)& ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_mode_set" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_mode_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->mode = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_mode_get" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  result = (SoSFEnum *)& ((arg1)->mode);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_handleEvent" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_GLRenderBelowPath" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLocateHighlight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLocateHighlight_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLocateHighlight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_GLRenderInPath" "', argument " "1"" of type '" "SoLocateHighlight *""'"); 
  }
  arg1 = reinterpret_cast< SoLocateHighlight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLocateHighlight_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLocateHighlight_turnOffCurrentHighlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLocateHighlight_turnOffCurrentHighlight" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  SoLocateHighlight::turnOffCurrentHighlight(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLocateHighlight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLocateHighlight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLocateHighlight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoLOD_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoLOD::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_getTypeId" "', argument " "1"" of type '" "SoLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  result = ((SoLOD const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLOD__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoLOD *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoLOD *)new SoLOD();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLOD, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLOD__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoLOD *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoLOD" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoLOD *)new SoLOD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoLOD, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoLOD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoLOD", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoLOD__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoLOD__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoLOD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoLOD::SoLOD()\n"
    "    SoLOD::SoLOD(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoLOD_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_initClass", 0, 0, 0)) SWIG_fail;
  SoLOD::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_range_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_range_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_range_set" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_range_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->range = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_range_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_range_get" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  result = (SoMFFloat *)& ((arg1)->range);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_center_set" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_center_get" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_doAction" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_callback" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_GLRender" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_GLRenderBelowPath" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_GLRenderInPath" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_GLRenderOffPath" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_rayPick" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_getBoundingBox" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_getPrimitiveCount" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_audioRender" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoLOD_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoLOD *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoLOD_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoLOD_notify" "', argument " "1"" of type '" "SoLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoLOD_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoLOD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoLOD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoLOD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPointSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPointSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_getTypeId" "', argument " "1"" of type '" "SoPointSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  result = ((SoPointSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_initClass", 0, 0, 0)) SWIG_fail;
  SoPointSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPointSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPointSet", 0, 0, 0)) SWIG_fail;
  result = (SoPointSet *)new SoPointSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPointSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_numPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_numPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_numPoints_set" "', argument " "1"" of type '" "SoPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSet_numPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_numPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_numPoints_get" "', argument " "1"" of type '" "SoPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_GLRender" "', argument " "1"" of type '" "SoPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_getBoundingBox" "', argument " "1"" of type '" "SoPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPointSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPointSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPointSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPointSet_getPrimitiveCount" "', argument " "1"" of type '" "SoPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPointSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPointSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPointSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPointSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMarkerSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMarkerSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMarkerSet_getTypeId" "', argument " "1"" of type '" "SoMarkerSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoMarkerSet * >(argp1);
  result = ((SoMarkerSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_initClass", 0, 0, 0)) SWIG_fail;
  SoMarkerSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMarkerSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMarkerSet", 0, 0, 0)) SWIG_fail;
  result = (SoMarkerSet *)new SoMarkerSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMarkerSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_markerIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_markerIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMarkerSet_markerIndex_set" "', argument " "1"" of type '" "SoMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoMarkerSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_markerIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->markerIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_markerIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMarkerSet_markerIndex_get" "', argument " "1"" of type '" "SoMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoMarkerSet * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->markerIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMarkerSet_GLRender" "', argument " "1"" of type '" "SoMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoMarkerSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMarkerSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMarkerSet_getPrimitiveCount" "', argument " "1"" of type '" "SoMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoMarkerSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_getNumDefinedMarkers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_getNumDefinedMarkers", 0, 0, 0)) SWIG_fail;
  result = (int)SoMarkerSet::getNumDefinedMarkers();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  unsigned char *arg3 = 0 ;
  SbBool arg4 ;
  SbBool arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMarkerSet_addMarker" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMarkerSet_addMarker" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMarkerSet_addMarker" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  SoMarkerSet::addMarker(arg1,(SbVec2s const &)*arg2,(unsigned char const *)arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  unsigned char *arg3 = 0 ;
  SbBool arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMarkerSet_addMarker" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMarkerSet_addMarker" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoMarkerSet::addMarker(arg1,(SbVec2s const &)*arg2,(unsigned char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  unsigned char *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMarkerSet_addMarker" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);
  SoMarkerSet::addMarker(arg1,(SbVec2s const &)*arg2,(unsigned char const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_getMarker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  unsigned char **arg3 = 0 ;
  SbBool *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_getMarker", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_getMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_getMarker" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_getMarker" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoMarkerSet_getMarker" "', argument " "3"" of type '" "unsigned char const *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_getMarker" "', argument " "3"" of type '" "unsigned char const *&""'"); 
  }
  arg3 = reinterpret_cast< unsigned char ** >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoMarkerSet_getMarker" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_getMarker" "', argument " "4"" of type '" "SbBool &""'"); 
  }
  arg4 = reinterpret_cast< SbBool * >(argp4);
  result = (SbBool)SoMarkerSet::getMarker(arg1,*arg2,(unsigned char const *&)*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_removeMarker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_removeMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SbBool)SoMarkerSet::removeMarker(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_isMarkerBitSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMarkerSet_isMarkerBitSet", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_isMarkerBitSet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoMarkerSet_isMarkerBitSet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)SoMarkerSet::isMarkerBitSet(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  SbBool arg4 ;
  SbBool arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMarkerSet_addMarker" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoMarkerSet_addMarker" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  SoMarkerSet_addMarker__SWIG_3(arg1,(SbVec2s const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  SbBool arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoMarkerSet_addMarker" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  SoMarkerSet_addMarker__SWIG_3(arg1,(SbVec2s const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  SbVec2s *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoMarkerSet_addMarker" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoMarkerSet_addMarker" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  arg3 = swig_obj[2];
  SoMarkerSet_addMarker__SWIG_3(arg1,(SbVec2s const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMarkerSet_addMarker(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoMarkerSet_addMarker", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoMarkerSet_addMarker__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoMarkerSet_addMarker__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMarkerSet_addMarker__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoMarkerSet_addMarker__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMarkerSet_addMarker__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoMarkerSet_addMarker__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoMarkerSet_addMarker'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoMarkerSet::addMarker(int,SbVec2s const &,unsigned char const *,SbBool,SbBool)\n"
    "    SoMarkerSet::addMarker(int,SbVec2s const &,unsigned char const *,SbBool)\n"
    "    SoMarkerSet::addMarker(int,SbVec2s const &,unsigned char const *)\n"
    "    SoMarkerSet::addMarker(int,SbVec2s const &,PyObject *,SbBool,SbBool)\n"
    "    SoMarkerSet::addMarker(int,SbVec2s const &,PyObject *,SbBool)\n"
    "    SoMarkerSet::SoMarkerSet_addMarker__SWIG_3(int,SbVec2s const &,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoMarkerSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMarkerSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMarkerSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMaterial_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMaterial::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_getTypeId" "', argument " "1"" of type '" "SoMaterial const *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = ((SoMaterial const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_initClass", 0, 0, 0)) SWIG_fail;
  SoMaterial::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMaterial", 0, 0, 0)) SWIG_fail;
  result = (SoMaterial *)new SoMaterial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMaterial, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_ambientColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_ambientColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_ambientColor_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_ambientColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->ambientColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_ambientColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_ambientColor_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFColor *)& ((arg1)->ambientColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_diffuseColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_diffuseColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_diffuseColor_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_diffuseColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->diffuseColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_diffuseColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_diffuseColor_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFColor *)& ((arg1)->diffuseColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_specularColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_specularColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_specularColor_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_specularColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->specularColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_specularColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_specularColor_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFColor *)& ((arg1)->specularColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_emissiveColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_emissiveColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_emissiveColor_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_emissiveColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->emissiveColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_emissiveColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_emissiveColor_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFColor *)& ((arg1)->emissiveColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_shininess_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_shininess_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_shininess_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_shininess_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->shininess = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_shininess_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_shininess_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFFloat *)& ((arg1)->shininess);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_transparency_set" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_transparency_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->transparency = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_transparency_get" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  result = (SoMFFloat *)& ((arg1)->transparency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_doAction" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_GLRender" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMaterial_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMaterial *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMaterial_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMaterial_callback" "', argument " "1"" of type '" "SoMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMaterial_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMaterial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMaterial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMaterial_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMatrixTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMatrixTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_getTypeId" "', argument " "1"" of type '" "SoMatrixTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  result = ((SoMatrixTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoMatrixTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMatrixTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMatrixTransform", 0, 0, 0)) SWIG_fail;
  result = (SoMatrixTransform *)new SoMatrixTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMatrixTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_matrix_set" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_matrix_set" "', argument " "2"" of type '" "SoSFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_matrix_get" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  result = (SoSFMatrix *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_doAction" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_callback" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_GLRender" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_getBoundingBox" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_getMatrix" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_pick" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMatrixTransform_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMatrixTransform *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMatrixTransform_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMatrixTransform_getPrimitiveCount" "', argument " "1"" of type '" "SoMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMatrixTransform_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMatrixTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMatrixTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMatrixTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoMultipleCopy_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoMultipleCopy::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_getTypeId" "', argument " "1"" of type '" "SoMultipleCopy const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  result = ((SoMultipleCopy const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_initClass", 0, 0, 0)) SWIG_fail;
  SoMultipleCopy::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoMultipleCopy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoMultipleCopy", 0, 0, 0)) SWIG_fail;
  result = (SoMultipleCopy *)new SoMultipleCopy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMultipleCopy, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_matrix_set" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_matrix_set" "', argument " "2"" of type '" "SoMFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_matrix_get" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  result = (SoMFMatrix *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_affectsState" "', argument " "1"" of type '" "SoMultipleCopy const *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  result = (SbBool)((SoMultipleCopy const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_doAction" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_callback" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_GLRender" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_pick" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_getBoundingBox" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_handleEvent" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_getMatrix" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_search" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_getPrimitiveCount" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoMultipleCopy_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoMultipleCopy *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoMultipleCopy_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoMultipleCopy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoMultipleCopy_audioRender" "', argument " "1"" of type '" "SoMultipleCopy *""'"); 
  }
  arg1 = reinterpret_cast< SoMultipleCopy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoMultipleCopy_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoMultipleCopy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoMultipleCopy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoMultipleCopy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPerspectiveCamera::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_getTypeId" "', argument " "1"" of type '" "SoPerspectiveCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  result = ((SoPerspectiveCamera const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_initClass", 0, 0, 0)) SWIG_fail;
  SoPerspectiveCamera::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPerspectiveCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPerspectiveCamera", 0, 0, 0)) SWIG_fail;
  result = (SoPerspectiveCamera *)new SoPerspectiveCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPerspectiveCamera, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_heightAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_heightAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_heightAngle_set" "', argument " "1"" of type '" "SoPerspectiveCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPerspectiveCamera_heightAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->heightAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_heightAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_heightAngle_get" "', argument " "1"" of type '" "SoPerspectiveCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->heightAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_scaleHeight" "', argument " "1"" of type '" "SoPerspectiveCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPerspectiveCamera_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_getViewVolume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_getViewVolume" "', argument " "1"" of type '" "SoPerspectiveCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPerspectiveCamera_getViewVolume" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SoPerspectiveCamera const *)arg1)->getViewVolume(arg2);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_getViewVolume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_getViewVolume" "', argument " "1"" of type '" "SoPerspectiveCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  result = ((SoPerspectiveCamera const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_getViewVolume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_getViewVolume", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPerspectiveCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPerspectiveCamera_getViewVolume__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPerspectiveCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoPerspectiveCamera_getViewVolume__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPerspectiveCamera_getViewVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPerspectiveCamera::getViewVolume(float) const\n"
    "    SoPerspectiveCamera::getViewVolume() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPerspectiveCamera_viewBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPerspectiveCamera *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPerspectiveCamera_viewBoundingBox", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPerspectiveCamera_viewBoundingBox" "', argument " "1"" of type '" "SoPerspectiveCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoPerspectiveCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPerspectiveCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPerspectiveCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPerspectiveCamera_viewBoundingBox" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPerspectiveCamera_viewBoundingBox" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->viewBoundingBox((SbBox3f const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPerspectiveCamera_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPerspectiveCamera, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPerspectiveCamera_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoReversePerspectiveCamera_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReversePerspectiveCamera_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoReversePerspectiveCamera::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReversePerspectiveCamera_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReversePerspectiveCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoReversePerspectiveCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoReversePerspectiveCamera_getTypeId" "', argument " "1"" of type '" "SoReversePerspectiveCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoReversePerspectiveCamera * >(argp1);
  result = ((SoReversePerspectiveCamera const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoReversePerspectiveCamera_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoReversePerspectiveCamera_initClass", 0, 0, 0)) SWIG_fail;
  SoReversePerspectiveCamera::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoReversePerspectiveCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoReversePerspectiveCamera *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoReversePerspectiveCamera", 0, 0, 0)) SWIG_fail;
  result = (SoReversePerspectiveCamera *)new SoReversePerspectiveCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoReversePerspectiveCamera, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoReversePerspectiveCamera_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoReversePerspectiveCamera, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoReversePerspectiveCamera_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoOrthographicCamera_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoOrthographicCamera::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_getTypeId" "', argument " "1"" of type '" "SoOrthographicCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  result = ((SoOrthographicCamera const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_initClass", 0, 0, 0)) SWIG_fail;
  SoOrthographicCamera::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOrthographicCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoOrthographicCamera", 0, 0, 0)) SWIG_fail;
  result = (SoOrthographicCamera *)new SoOrthographicCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOrthographicCamera, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_height_set" "', argument " "1"" of type '" "SoOrthographicCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOrthographicCamera_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_height_get" "', argument " "1"" of type '" "SoOrthographicCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_scaleHeight" "', argument " "1"" of type '" "SoOrthographicCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOrthographicCamera_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_getViewVolume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_getViewVolume" "', argument " "1"" of type '" "SoOrthographicCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOrthographicCamera_getViewVolume" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SoOrthographicCamera const *)arg1)->getViewVolume(arg2);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_getViewVolume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_getViewVolume" "', argument " "1"" of type '" "SoOrthographicCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  result = ((SoOrthographicCamera const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_getViewVolume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_getViewVolume", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOrthographicCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoOrthographicCamera_getViewVolume__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOrthographicCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoOrthographicCamera_getViewVolume__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOrthographicCamera_getViewVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOrthographicCamera::getViewVolume(float) const\n"
    "    SoOrthographicCamera::getViewVolume() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOrthographicCamera_viewBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOrthographicCamera *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOrthographicCamera_viewBoundingBox", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOrthographicCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOrthographicCamera_viewBoundingBox" "', argument " "1"" of type '" "SoOrthographicCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoOrthographicCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOrthographicCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOrthographicCamera_viewBoundingBox" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoOrthographicCamera_viewBoundingBox" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoOrthographicCamera_viewBoundingBox" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->viewBoundingBox((SbBox3f const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOrthographicCamera_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOrthographicCamera, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOrthographicCamera_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFrustumCamera_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFrustumCamera::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_getTypeId" "', argument " "1"" of type '" "SoFrustumCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = ((SoFrustumCamera const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_initClass", 0, 0, 0)) SWIG_fail;
  SoFrustumCamera::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFrustumCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFrustumCamera", 0, 0, 0)) SWIG_fail;
  result = (SoFrustumCamera *)new SoFrustumCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFrustumCamera, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_left_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_left_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_left_set" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFrustumCamera_left_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->left = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_left_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_left_get" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->left);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_right_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_right_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_right_set" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFrustumCamera_right_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->right = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_right_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_right_get" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->right);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_top_set" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFrustumCamera_top_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->top = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_top_get" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->top);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_bottom_set" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoFrustumCamera_bottom_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->bottom = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_bottom_get" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = (SoSFFloat *)& ((arg1)->bottom);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_scaleHeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFrustumCamera_scaleHeight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_scaleHeight" "', argument " "1"" of type '" "SoFrustumCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFrustumCamera_scaleHeight" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->scaleHeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_getViewVolume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_getViewVolume" "', argument " "1"" of type '" "SoFrustumCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoFrustumCamera_getViewVolume" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = ((SoFrustumCamera const *)arg1)->getViewVolume(arg2);
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_getViewVolume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoFrustumCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbViewVolume result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFrustumCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFrustumCamera_getViewVolume" "', argument " "1"" of type '" "SoFrustumCamera const *""'"); 
  }
  arg1 = reinterpret_cast< SoFrustumCamera * >(argp1);
  result = ((SoFrustumCamera const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj((new SbViewVolume(result)), SWIGTYPE_p_SbViewVolume, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFrustumCamera_getViewVolume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoFrustumCamera_getViewVolume", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFrustumCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoFrustumCamera_getViewVolume__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoFrustumCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoFrustumCamera_getViewVolume__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoFrustumCamera_getViewVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoFrustumCamera::getViewVolume(float) const\n"
    "    SoFrustumCamera::getViewVolume() const\n");
  return 0;
}


SWIGINTERN PyObject *SoFrustumCamera_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFrustumCamera, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFrustumCamera_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoQuadMesh_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoQuadMesh::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_getTypeId" "', argument " "1"" of type '" "SoQuadMesh const *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  result = ((SoQuadMesh const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_initClass", 0, 0, 0)) SWIG_fail;
  SoQuadMesh::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQuadMesh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoQuadMesh", 0, 0, 0)) SWIG_fail;
  result = (SoQuadMesh *)new SoQuadMesh();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQuadMesh, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_verticesPerColumn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_verticesPerColumn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_verticesPerColumn_set" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQuadMesh_verticesPerColumn_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->verticesPerColumn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_verticesPerColumn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_verticesPerColumn_get" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->verticesPerColumn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_verticesPerRow_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_verticesPerRow_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_verticesPerRow_set" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQuadMesh_verticesPerRow_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->verticesPerRow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_verticesPerRow_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_verticesPerRow_get" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->verticesPerRow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_GLRender" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQuadMesh_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_getPrimitiveCount" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQuadMesh_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQuadMesh_generateDefaultNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQuadMesh *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQuadMesh_generateDefaultNormals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQuadMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQuadMesh_generateDefaultNormals" "', argument " "1"" of type '" "SoQuadMesh *""'"); 
  }
  arg1 = reinterpret_cast< SoQuadMesh * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQuadMesh_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQuadMesh_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoQuadMesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoQuadMesh, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoQuadMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTriangleStripSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTriangleStripSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_getTypeId" "', argument " "1"" of type '" "SoTriangleStripSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  result = ((SoTriangleStripSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_initClass", 0, 0, 0)) SWIG_fail;
  SoTriangleStripSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTriangleStripSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTriangleStripSet", 0, 0, 0)) SWIG_fail;
  result = (SoTriangleStripSet *)new SoTriangleStripSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTriangleStripSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_numVertices_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_numVertices_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_numVertices_set" "', argument " "1"" of type '" "SoTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriangleStripSet_numVertices_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->numVertices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_numVertices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_numVertices_get" "', argument " "1"" of type '" "SoTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->numVertices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_GLRender" "', argument " "1"" of type '" "SoTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriangleStripSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_getPrimitiveCount" "', argument " "1"" of type '" "SoTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriangleStripSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTriangleStripSet_generateDefaultNormals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTriangleStripSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTriangleStripSet_generateDefaultNormals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTriangleStripSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTriangleStripSet_generateDefaultNormals" "', argument " "1"" of type '" "SoTriangleStripSet *""'"); 
  }
  arg1 = reinterpret_cast< SoTriangleStripSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTriangleStripSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTriangleStripSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTriangleStripSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTriangleStripSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTriangleStripSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedPointSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedPointSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedPointSet_getTypeId" "', argument " "1"" of type '" "SoIndexedPointSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedPointSet * >(argp1);
  result = ((SoIndexedPointSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedPointSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedPointSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedPointSet", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedPointSet *)new SoIndexedPointSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedPointSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedPointSet_GLRender" "', argument " "1"" of type '" "SoIndexedPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedPointSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedPointSet_getBoundingBox" "', argument " "1"" of type '" "SoIndexedPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedPointSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedPointSet_getPrimitiveCount" "', argument " "1"" of type '" "SoIndexedPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedPointSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedPointSet_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedPointSet *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedPointSet_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedPointSet_notify" "', argument " "1"" of type '" "SoIndexedPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedPointSet_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedPointSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedPointSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedPointSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedMarkerSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoIndexedMarkerSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedMarkerSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedMarkerSet_getTypeId" "', argument " "1"" of type '" "SoIndexedMarkerSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedMarkerSet * >(argp1);
  result = ((SoIndexedMarkerSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedMarkerSet_initClass", 0, 0, 0)) SWIG_fail;
  SoIndexedMarkerSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIndexedMarkerSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedMarkerSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIndexedMarkerSet", 0, 0, 0)) SWIG_fail;
  result = (SoIndexedMarkerSet *)new SoIndexedMarkerSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIndexedMarkerSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_markerIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedMarkerSet *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedMarkerSet_markerIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedMarkerSet_markerIndex_set" "', argument " "1"" of type '" "SoIndexedMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedMarkerSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedMarkerSet_markerIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->markerIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_markerIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedMarkerSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedMarkerSet_markerIndex_get" "', argument " "1"" of type '" "SoIndexedMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedMarkerSet * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->markerIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoIndexedMarkerSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIndexedMarkerSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoIndexedMarkerSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIndexedMarkerSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoIndexedMarkerSet_GLRender" "', argument " "1"" of type '" "SoIndexedMarkerSet *""'"); 
  }
  arg1 = reinterpret_cast< SoIndexedMarkerSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoIndexedMarkerSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIndexedMarkerSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIndexedMarkerSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIndexedMarkerSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNurbsCurve_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNurbsCurve::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_getTypeId" "', argument " "1"" of type '" "SoNurbsCurve const *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  result = ((SoNurbsCurve const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_initClass", 0, 0, 0)) SWIG_fail;
  SoNurbsCurve::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNurbsCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNurbsCurve", 0, 0, 0)) SWIG_fail;
  result = (SoNurbsCurve *)new SoNurbsCurve();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNurbsCurve, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_numControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_numControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_numControlPoints_set" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_numControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_numControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_numControlPoints_get" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_knotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_knotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_knotVector_set" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_knotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->knotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_knotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_knotVector_get" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  result = (SoMFFloat *)& ((arg1)->knotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_GLRender" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_rayPick" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_getPrimitiveCount" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_getBoundingBox" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsCurve_sendPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsCurve *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SoPrimitiveVertex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsCurve_sendPrimitive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsCurve_sendPrimitive" "', argument " "1"" of type '" "SoNurbsCurve *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsCurve_sendPrimitive" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNurbsCurve_sendPrimitive" "', argument " "3"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  (arg1)->sendPrimitive(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNurbsCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNurbsCurve, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNurbsCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNurbsSurface_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNurbsSurface::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_getTypeId" "', argument " "1"" of type '" "SoNurbsSurface const *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = ((SoNurbsSurface const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_initClass", 0, 0, 0)) SWIG_fail;
  SoNurbsSurface::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNurbsSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNurbsSurface", 0, 0, 0)) SWIG_fail;
  result = (SoNurbsSurface *)new SoNurbsSurface();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNurbsSurface, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numUControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_numUControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numUControlPoints_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_numUControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numUControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numUControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numUControlPoints_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numUControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numVControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_numVControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numVControlPoints_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_numVControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numVControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numVControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numVControlPoints_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numVControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numSControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_numSControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numSControlPoints_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_numSControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numSControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numSControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numSControlPoints_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numSControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numTControlPoints_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_numTControlPoints_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numTControlPoints_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_numTControlPoints_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numTControlPoints = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_numTControlPoints_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_numTControlPoints_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numTControlPoints);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_uKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_uKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_uKnotVector_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_uKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->uKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_uKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_uKnotVector_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->uKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_vKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_vKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_vKnotVector_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_vKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->vKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_vKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_vKnotVector_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->vKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_sKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_sKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_sKnotVector_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_sKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->sKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_sKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_sKnotVector_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->sKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_tKnotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_tKnotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_tKnotVector_set" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_tKnotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->tKnotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_tKnotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_tKnotVector_get" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  result = (SoMFFloat *)& ((arg1)->tKnotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_GLRender" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_rayPick" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_getPrimitiveCount" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsSurface_sendPrimitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsSurface *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SoPrimitiveVertex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsSurface_sendPrimitive", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsSurface_sendPrimitive" "', argument " "1"" of type '" "SoNurbsSurface *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsSurface * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsSurface_sendPrimitive" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNurbsSurface_sendPrimitive" "', argument " "3"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg3 = reinterpret_cast< SoPrimitiveVertex * >(argp3);
  (arg1)->sendPrimitive(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNurbsSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNurbsSurface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNurbsSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSphere_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSphere::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_getTypeId" "', argument " "1"" of type '" "SoSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  result = ((SoSphere const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_initClass", 0, 0, 0)) SWIG_fail;
  SoSphere::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSphere", 0, 0, 0)) SWIG_fail;
  result = (SoSphere *)new SoSphere();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSphere, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_radius_set" "', argument " "1"" of type '" "SoSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSphere_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_radius_get" "', argument " "1"" of type '" "SoSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_GLRender" "', argument " "1"" of type '" "SoSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSphere_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_rayPick" "', argument " "1"" of type '" "SoSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSphere_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSphere_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSphere *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSphere_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSphere_getPrimitiveCount" "', argument " "1"" of type '" "SoSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSphere_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSphere_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSphere, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSphere_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoText2_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoText2::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_getTypeId" "', argument " "1"" of type '" "SoText2 const *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  result = ((SoText2 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_initClass", 0, 0, 0)) SWIG_fail;
  SoText2::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoText2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoText2", 0, 0, 0)) SWIG_fail;
  result = (SoText2 *)new SoText2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoText2, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_string_set" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_string_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->string = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_string_get" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  result = (SoMFString *)& ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_spacing_set" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_spacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->spacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_spacing_get" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  result = (SoSFFloat *)& ((arg1)->spacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_justification_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_justification_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_justification_set" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_justification_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->justification = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_justification_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_justification_get" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->justification);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_GLRender" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_rayPick" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText2_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText2 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText2_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText2_getPrimitiveCount" "', argument " "1"" of type '" "SoText2 *""'"); 
  }
  arg1 = reinterpret_cast< SoText2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText2_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoText2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoText2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoText2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoText3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoText3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_getTypeId" "', argument " "1"" of type '" "SoText3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  result = ((SoText3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_initClass", 0, 0, 0)) SWIG_fail;
  SoText3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoText3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoText3", 0, 0, 0)) SWIG_fail;
  result = (SoText3 *)new SoText3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoText3, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_string_set" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_string_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->string = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_string_get" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  result = (SoMFString *)& ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_spacing_set" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_spacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->spacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_spacing_get" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  result = (SoSFFloat *)& ((arg1)->spacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_justification_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_justification_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_justification_set" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_justification_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->justification = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_justification_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_justification_get" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->justification);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_parts_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_parts_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_parts_set" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_parts_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->parts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_parts_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_parts_get" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->parts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_getCharacterBounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBox3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_getCharacterBounds", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_getCharacterBounds" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_getCharacterBounds" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoText3_getCharacterBounds" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoText3_getCharacterBounds" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (arg1)->getCharacterBounds(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new SbBox3f(result)), SWIGTYPE_p_SbBox3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_GLRender" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoText3_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoText3 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoText3_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoText3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoText3_getPrimitiveCount" "', argument " "1"" of type '" "SoText3 *""'"); 
  }
  arg1 = reinterpret_cast< SoText3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoText3_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoText3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoText3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoText3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoWWWAnchor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoWWWAnchor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_getTypeId" "', argument " "1"" of type '" "SoWWWAnchor const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  result = ((SoWWWAnchor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_initClass", 0, 0, 0)) SWIG_fail;
  SoWWWAnchor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWWWAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoWWWAnchor", 0, 0, 0)) SWIG_fail;
  result = (SoWWWAnchor *)new SoWWWAnchor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoWWWAnchor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_name_set" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_name_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_name_get" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  result = (SoSFString *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_description_set" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_description_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->description = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_description_get" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  result = (SoSFString *)& ((arg1)->description);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_map_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_map_set" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_map_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_map_get" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  result = (SoSFEnum *)& ((arg1)->map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_setFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_setFullURLName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_setFullURLName" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setFullURLName((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_getFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_getFullURLName" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  result = (SbString *) &(arg1)->getFullURLName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchor *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWAnchor_handleEvent" "', argument " "1"" of type '" "SoWWWAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_setFetchURLCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_setFetchURLCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoWWWAnchor_setFetchURLCallBack" "', argument " "1"" of type '" "SoWWWAnchorCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_setFetchURLCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoWWWAnchor::setFetchURLCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWAnchor_setHighlightURLCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWAnchorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWAnchor_setHighlightURLCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoWWWAnchor_setHighlightURLCallBack" "', argument " "1"" of type '" "SoWWWAnchorCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWAnchor_setHighlightURLCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoWWWAnchor::setHighlightURLCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoWWWAnchor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoWWWAnchor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoWWWAnchor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPathSwitch_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPathSwitch::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_getTypeId" "', argument " "1"" of type '" "SoPathSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  result = ((SoPathSwitch const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_initClass", 0, 0, 0)) SWIG_fail;
  SoPathSwitch::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathSwitch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoPathSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoPathSwitch *)new SoPathSwitch();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathSwitch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoPathSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoPathSwitch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoPathSwitch *)new SoPathSwitch(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathSwitch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPathSwitch", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoPathSwitch__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoPathSwitch__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPathSwitch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPathSwitch::SoPathSwitch()\n"
    "    SoPathSwitch::SoPathSwitch(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoSFPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_path_set" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_path_set" "', argument " "2"" of type '" "SoSFPath *""'"); 
  }
  arg2 = reinterpret_cast< SoSFPath * >(argp2);
  if (arg1) (arg1)->path = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_path_get" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  result = (SoSFPath *)& ((arg1)->path);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFPath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_doAction" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_GLRender" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_pick" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_getBoundingBox" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_handleEvent" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_getMatrix" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_search" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_callback" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_getPrimitiveCount" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSwitch_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSwitch *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSwitch_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSwitch_audioRender" "', argument " "1"" of type '" "SoPathSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSwitch_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPathSwitch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPathSwitch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPathSwitch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransformSeparator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransformSeparator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_getTypeId" "', argument " "1"" of type '" "SoTransformSeparator const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  result = ((SoTransformSeparator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_initClass", 0, 0, 0)) SWIG_fail;
  SoTransformSeparator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformSeparator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoTransformSeparator *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoTransformSeparator *)new SoTransformSeparator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformSeparator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformSeparator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoTransformSeparator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoTransformSeparator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoTransformSeparator *)new SoTransformSeparator(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransformSeparator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransformSeparator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoTransformSeparator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoTransformSeparator__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoTransformSeparator__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoTransformSeparator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoTransformSeparator::SoTransformSeparator()\n"
    "    SoTransformSeparator::SoTransformSeparator(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_doAction" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_callback" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_GLRender" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_pick" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_getBoundingBox" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_getMatrix" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_getPrimitiveCount" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransformSeparator_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransformSeparator *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransformSeparator_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransformSeparator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransformSeparator_audioRender" "', argument " "1"" of type '" "SoTransformSeparator *""'"); 
  }
  arg1 = reinterpret_cast< SoTransformSeparator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransformSeparator_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransformSeparator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransformSeparator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransformSeparator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_getTypeId" "', argument " "1"" of type '" "SoRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  result = ((SoRotation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_initClass", 0, 0, 0)) SWIG_fail;
  SoRotation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotation", 0, 0, 0)) SWIG_fail;
  result = (SoRotation *)new SoRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_rotation_set" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_rotation_get" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_doAction" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_GLRender" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_callback" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_getBoundingBox" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_getMatrix" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_pick" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotation_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotation *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotation_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotation_getPrimitiveCount" "', argument " "1"" of type '" "SoRotation *""'"); 
  }
  arg1 = reinterpret_cast< SoRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotation_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPendulum_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPendulum::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_getTypeId" "', argument " "1"" of type '" "SoPendulum const *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  result = ((SoPendulum const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_initClass", 0, 0, 0)) SWIG_fail;
  SoPendulum::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPendulum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPendulum", 0, 0, 0)) SWIG_fail;
  result = (SoPendulum *)new SoPendulum();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPendulum, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_rotation0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_rotation0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_rotation0_set" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPendulum_rotation0_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_rotation0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_rotation0_get" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_rotation1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_rotation1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_rotation1_set" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPendulum_rotation1_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_rotation1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_rotation1_get" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_speed_set" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPendulum_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_speed_get" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_on_set" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPendulum_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_on_get" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPendulum_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPendulum *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPendulum_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPendulum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPendulum_write" "', argument " "1"" of type '" "SoPendulum *""'"); 
  }
  arg1 = reinterpret_cast< SoPendulum * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPendulum_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPendulum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPendulum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPendulum_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotor_getTypeId" "', argument " "1"" of type '" "SoRotor const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotor * >(argp1);
  result = ((SoRotor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotor_initClass", 0, 0, 0)) SWIG_fail;
  SoRotor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotor", 0, 0, 0)) SWIG_fail;
  result = (SoRotor *)new SoRotor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotor_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotor_speed_set" "', argument " "1"" of type '" "SoRotor *""'"); 
  }
  arg1 = reinterpret_cast< SoRotor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotor_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotor_speed_get" "', argument " "1"" of type '" "SoRotor *""'"); 
  }
  arg1 = reinterpret_cast< SoRotor * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotor_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotor_on_set" "', argument " "1"" of type '" "SoRotor *""'"); 
  }
  arg1 = reinterpret_cast< SoRotor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotor_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotor_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotor_on_get" "', argument " "1"" of type '" "SoRotor *""'"); 
  }
  arg1 = reinterpret_cast< SoRotor * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoResetTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoResetTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_getTypeId" "', argument " "1"" of type '" "SoResetTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  result = ((SoResetTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoResetTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoResetTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoResetTransform", 0, 0, 0)) SWIG_fail;
  result = (SoResetTransform *)new SoResetTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoResetTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_whatToReset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_whatToReset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_whatToReset_set" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_whatToReset_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->whatToReset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_whatToReset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_whatToReset_get" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->whatToReset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_doAction" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_callback" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_GLRender" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_getBoundingBox" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_getMatrix" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_pick" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoResetTransform_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoResetTransform *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoResetTransform_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoResetTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoResetTransform_getPrimitiveCount" "', argument " "1"" of type '" "SoResetTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoResetTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoResetTransform_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoResetTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoResetTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoResetTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoRotationXYZ_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoRotationXYZ::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_getTypeId" "', argument " "1"" of type '" "SoRotationXYZ const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  result = ((SoRotationXYZ const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_initClass", 0, 0, 0)) SWIG_fail;
  SoRotationXYZ::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoRotationXYZ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRotationXYZ", 0, 0, 0)) SWIG_fail;
  result = (SoRotationXYZ *)new SoRotationXYZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRotationXYZ, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_axis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_axis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_axis_set" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_axis_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->axis = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_axis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_axis_get" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  result = (SoSFEnum *)& ((arg1)->axis);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_angle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_angle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_angle_set" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_angle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->angle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_angle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_angle_get" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  result = (SoSFFloat *)& ((arg1)->angle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRotation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_getRotation" "', argument " "1"" of type '" "SoRotationXYZ const *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  result = ((SoRotationXYZ const *)arg1)->getRotation();
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_doAction" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_GLRender" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_callback" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_getBoundingBox" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_getMatrix" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_pick" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRotationXYZ_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRotationXYZ *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRotationXYZ_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRotationXYZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRotationXYZ_getPrimitiveCount" "', argument " "1"" of type '" "SoRotationXYZ *""'"); 
  }
  arg1 = reinterpret_cast< SoRotationXYZ * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRotationXYZ_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoRotationXYZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRotationXYZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRotationXYZ_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTranslation_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTranslation::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_getTypeId" "', argument " "1"" of type '" "SoTranslation const *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  result = ((SoTranslation const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_initClass", 0, 0, 0)) SWIG_fail;
  SoTranslation::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTranslation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTranslation", 0, 0, 0)) SWIG_fail;
  result = (SoTranslation *)new SoTranslation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTranslation, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_translation_set" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_translation_get" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_doAction" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_callback" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_GLRender" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_getBoundingBox" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_getMatrix" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_pick" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTranslation_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTranslation *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTranslation_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTranslation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTranslation_getPrimitiveCount" "', argument " "1"" of type '" "SoTranslation *""'"); 
  }
  arg1 = reinterpret_cast< SoTranslation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTranslation_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTranslation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTranslation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTranslation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShuttle_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShuttle::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_getTypeId" "', argument " "1"" of type '" "SoShuttle const *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  result = ((SoShuttle const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_initClass", 0, 0, 0)) SWIG_fail;
  SoShuttle::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShuttle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShuttle", 0, 0, 0)) SWIG_fail;
  result = (SoShuttle *)new SoShuttle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShuttle, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_translation0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_translation0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_translation0_set" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShuttle_translation0_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation0 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_translation0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_translation0_get" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation0);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_translation1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_translation1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_translation1_set" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShuttle_translation1_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_translation1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_translation1_get" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_speed_set" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShuttle_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_speed_get" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_on_set" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShuttle_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_on_get" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShuttle_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShuttle *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShuttle_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShuttle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShuttle_write" "', argument " "1"" of type '" "SoShuttle *""'"); 
  }
  arg1 = reinterpret_cast< SoShuttle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShuttle_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShuttle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShuttle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShuttle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSurroundScale_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSurroundScale::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_getTypeId" "', argument " "1"" of type '" "SoSurroundScale const *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  result = ((SoSurroundScale const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_initClass", 0, 0, 0)) SWIG_fail;
  SoSurroundScale::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSurroundScale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSurroundScale", 0, 0, 0)) SWIG_fail;
  result = (SoSurroundScale *)new SoSurroundScale();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSurroundScale, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_numNodesUpToContainer_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_numNodesUpToContainer_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_numNodesUpToContainer_set" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSurroundScale_numNodesUpToContainer_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numNodesUpToContainer = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_numNodesUpToContainer_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_numNodesUpToContainer_get" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numNodesUpToContainer);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_numNodesUpToReset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_numNodesUpToReset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_numNodesUpToReset_set" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSurroundScale_numNodesUpToReset_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->numNodesUpToReset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_numNodesUpToReset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_numNodesUpToReset_get" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->numNodesUpToReset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_invalidate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_invalidate" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  (arg1)->invalidate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_doAction" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSurroundScale_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_setDoingTranslations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSurroundScale_setDoingTranslations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_setDoingTranslations" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSurroundScale_setDoingTranslations" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDoingTranslations(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSurroundScale_isDoingTranslations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSurroundScale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSurroundScale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSurroundScale_isDoingTranslations" "', argument " "1"" of type '" "SoSurroundScale *""'"); 
  }
  arg1 = reinterpret_cast< SoSurroundScale * >(argp1);
  result = (SbBool)(arg1)->isDoingTranslations();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSurroundScale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSurroundScale, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSurroundScale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNurbsProfile_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsProfile_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNurbsProfile::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsProfile_getTypeId" "', argument " "1"" of type '" "SoNurbsProfile const *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsProfile * >(argp1);
  result = ((SoNurbsProfile const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsProfile_initClass", 0, 0, 0)) SWIG_fail;
  SoNurbsProfile::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNurbsProfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNurbsProfile", 0, 0, 0)) SWIG_fail;
  result = (SoNurbsProfile *)new SoNurbsProfile();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNurbsProfile, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_knotVector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsProfile_knotVector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsProfile_knotVector_set" "', argument " "1"" of type '" "SoNurbsProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsProfile_knotVector_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->knotVector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_knotVector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsProfile_knotVector_get" "', argument " "1"" of type '" "SoNurbsProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsProfile * >(argp1);
  result = (SoMFFloat *)& ((arg1)->knotVector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_getTrimCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  float **arg4 = 0 ;
  int *arg5 = 0 ;
  int32_t *arg6 = 0 ;
  float **arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsProfile_getTrimCurve", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "1"" of type '" "SoNurbsProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "4"" of type '" "float *&""'"); 
  }
  arg4 = reinterpret_cast< float ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "6"" of type '" "int32_t &""'"); 
  }
  arg6 = reinterpret_cast< int32_t * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_p_float,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getTrimCurve" "', argument " "7"" of type '" "float *&""'"); 
  }
  arg7 = reinterpret_cast< float ** >(argp7);
  (arg1)->getTrimCurve(arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNurbsProfile_getVertices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNurbsProfile *arg1 = 0 ;
  SoState *arg2 = 0 ;
  int32_t *arg3 = 0 ;
  SbVec2f **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNurbsProfile_getVertices", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNurbsProfile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNurbsProfile_getVertices" "', argument " "1"" of type '" "SoNurbsProfile *""'"); 
  }
  arg1 = reinterpret_cast< SoNurbsProfile * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNurbsProfile_getVertices" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoNurbsProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getVertices" "', argument " "3"" of type '" "int32_t &""'"); 
  }
  arg3 = reinterpret_cast< int32_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoNurbsProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoNurbsProfile_getVertices" "', argument " "4"" of type '" "SbVec2f *&""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f ** >(argp4);
  (arg1)->getVertices(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNurbsProfile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNurbsProfile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNurbsProfile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoVertexAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVertexAttribute", 0, 0, 0)) SWIG_fail;
  result = (SoVertexAttribute *)new SoVertexAttribute();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVertexAttribute, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexAttribute::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexAttribute::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_getTypeId" "', argument " "1"" of type '" "SoVertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  result = ((SoVertexAttribute const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_name_set" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_name_set" "', argument " "2"" of type '" "SoSFName *""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_name_get" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  result = (SoSFName *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_typeName_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoSFName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_typeName_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_typeName_set" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFName, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_typeName_set" "', argument " "2"" of type '" "SoSFName *""'"); 
  }
  arg2 = reinterpret_cast< SoSFName * >(argp2);
  if (arg1) (arg1)->typeName = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_typeName_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_typeName_get" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  result = (SoSFName *)& ((arg1)->typeName);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_getValuesField(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMField *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_getValuesField" "', argument " "1"" of type '" "SoVertexAttribute const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  result = (SoMField *)((SoVertexAttribute const *)arg1)->getValuesField();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMField, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_doAction" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_GLRender" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_write" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_copyContents" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVertexAttribute_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttribute_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttribute *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttribute_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttribute_notify" "', argument " "1"" of type '" "SoVertexAttribute *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttribute * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttribute_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexAttribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexAttribute, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVertexAttribute_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexAttributeBinding::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_getTypeId" "', argument " "1"" of type '" "SoVertexAttributeBinding const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  result = ((SoVertexAttributeBinding const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexAttributeBinding::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVertexAttributeBinding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVertexAttributeBinding", 0, 0, 0)) SWIG_fail;
  result = (SoVertexAttributeBinding *)new SoVertexAttributeBinding();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVertexAttributeBinding, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_value_set" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_value_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_value_get" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  result = (SoSFEnum *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_doAction" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_GLRender" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_callback" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_pick" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexAttributeBinding_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexAttributeBinding *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexAttributeBinding_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexAttributeBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexAttributeBinding_getPrimitiveCount" "', argument " "1"" of type '" "SoVertexAttributeBinding *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexAttributeBinding * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVertexAttributeBinding_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexAttributeBinding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexAttributeBinding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVertexAttributeBinding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoNormal_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoNormal::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_getTypeId" "', argument " "1"" of type '" "SoNormal const *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  result = ((SoNormal const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_initClass", 0, 0, 0)) SWIG_fail;
  SoNormal::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNormal", 0, 0, 0)) SWIG_fail;
  result = (SoNormal *)new SoNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNormal, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_vector_set" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_vector_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_vector_get" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_doAction" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_GLRender" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_callback" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_pick" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNormal_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNormal *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNormal_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNormal_getPrimitiveCount" "', argument " "1"" of type '" "SoNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNormal_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPackedColor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPackedColor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_getTypeId" "', argument " "1"" of type '" "SoPackedColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  result = ((SoPackedColor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_initClass", 0, 0, 0)) SWIG_fail;
  SoPackedColor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPackedColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPackedColor", 0, 0, 0)) SWIG_fail;
  result = (SoPackedColor *)new SoPackedColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPackedColor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_orderedRGBA_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  SoMFUInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_orderedRGBA_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_orderedRGBA_set" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPackedColor_orderedRGBA_set" "', argument " "2"" of type '" "SoMFUInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFUInt32 * >(argp2);
  if (arg1) (arg1)->orderedRGBA = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_orderedRGBA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFUInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_orderedRGBA_get" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  result = (SoMFUInt32 *)& ((arg1)->orderedRGBA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFUInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_doAction" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPackedColor_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_GLRender" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPackedColor_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPackedColor_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_callback" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPackedColor_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPackedColor_isTransparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPackedColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPackedColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPackedColor_isTransparent" "', argument " "1"" of type '" "SoPackedColor *""'"); 
  }
  arg1 = reinterpret_cast< SoPackedColor * >(argp1);
  result = (SbBool)(arg1)->isTransparent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPackedColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPackedColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPackedColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoPolygonOffset_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoPolygonOffset::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_getTypeId" "', argument " "1"" of type '" "SoPolygonOffset const *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  result = ((SoPolygonOffset const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_initClass", 0, 0, 0)) SWIG_fail;
  SoPolygonOffset::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPolygonOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPolygonOffset", 0, 0, 0)) SWIG_fail;
  result = (SoPolygonOffset *)new SoPolygonOffset();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPolygonOffset, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_factor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_factor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_factor_set" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_factor_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->factor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_factor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_factor_get" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  result = (SoSFFloat *)& ((arg1)->factor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_units_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_units_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_units_set" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_units_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->units = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_units_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_units_get" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  result = (SoSFFloat *)& ((arg1)->units);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_styles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoSFBitMask *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_styles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_styles_set" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_styles_set" "', argument " "2"" of type '" "SoSFBitMask *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBitMask * >(argp2);
  if (arg1) (arg1)->styles = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_styles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBitMask *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_styles_get" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  result = (SoSFBitMask *)& ((arg1)->styles);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBitMask, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_on_set" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_on_get" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_doAction" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_callback" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPolygonOffset_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPolygonOffset *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPolygonOffset_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPolygonOffset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPolygonOffset_GLRender" "', argument " "1"" of type '" "SoPolygonOffset *""'"); 
  }
  arg1 = reinterpret_cast< SoPolygonOffset * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPolygonOffset_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPolygonOffset_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPolygonOffset, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPolygonOffset_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProfileCoordinate2::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_getTypeId" "', argument " "1"" of type '" "SoProfileCoordinate2 const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  result = ((SoProfileCoordinate2 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_initClass", 0, 0, 0)) SWIG_fail;
  SoProfileCoordinate2::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoProfileCoordinate2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoProfileCoordinate2", 0, 0, 0)) SWIG_fail;
  result = (SoProfileCoordinate2 *)new SoProfileCoordinate2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProfileCoordinate2, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_point_set" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_point_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_point_get" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_doAction" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_GLRender" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_callback" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_pick" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_getBoundingBox" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate2_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate2 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate2_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate2_getPrimitiveCount" "', argument " "1"" of type '" "SoProfileCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate2_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProfileCoordinate2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProfileCoordinate2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoProfileCoordinate2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoProfileCoordinate3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_getTypeId" "', argument " "1"" of type '" "SoProfileCoordinate3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  result = ((SoProfileCoordinate3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_initClass", 0, 0, 0)) SWIG_fail;
  SoProfileCoordinate3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoProfileCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoProfileCoordinate3", 0, 0, 0)) SWIG_fail;
  result = (SoProfileCoordinate3 *)new SoProfileCoordinate3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoProfileCoordinate3, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_point_set" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_point_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_point_get" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_doAction" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_GLRender" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_callback" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_pick" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_getBoundingBox" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoProfileCoordinate3_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoProfileCoordinate3 *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoProfileCoordinate3_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoProfileCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoProfileCoordinate3_getPrimitiveCount" "', argument " "1"" of type '" "SoProfileCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoProfileCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoProfileCoordinate3_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoProfileCoordinate3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoProfileCoordinate3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoProfileCoordinate3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTexture3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_getTypeId" "', argument " "1"" of type '" "SoTexture3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = ((SoTexture3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTexture3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTexture3", 0, 0, 0)) SWIG_fail;
  result = (SoTexture3 *)new SoTexture3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTexture3, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_filenames_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_filenames_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_filenames_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_filenames_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->filenames = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_filenames_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_filenames_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoMFString *)& ((arg1)->filenames);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_images_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFImage3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_images_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_images_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_images_set" "', argument " "2"" of type '" "SoSFImage3 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage3 * >(argp2);
  if (arg1) (arg1)->images = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_images_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage3 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_images_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFImage3 *)& ((arg1)->images);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage3, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_wrapR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapR_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_wrapR_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapR_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapS_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapS_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapT_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_wrapT_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_model_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_model_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_blendColor_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_blendColor_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_enableCompressedTexture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_enableCompressedTexture_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_enableCompressedTexture_set" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_enableCompressedTexture_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enableCompressedTexture = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_enableCompressedTexture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_enableCompressedTexture_get" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  result = (SoSFBool *)& ((arg1)->enableCompressedTexture);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_doAction" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_GLRender" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3_callback" "', argument " "1"" of type '" "SoTexture3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTexture3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTexture3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTexture2Transform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture2Transform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_getTypeId" "', argument " "1"" of type '" "SoTexture2Transform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  result = ((SoTexture2Transform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture2Transform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTexture2Transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTexture2Transform", 0, 0, 0)) SWIG_fail;
  result = (SoTexture2Transform *)new SoTexture2Transform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTexture2Transform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_translation_set" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_translation_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_translation_get" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_rotation_set" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_rotation_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_rotation_get" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  result = (SoSFFloat *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_scaleFactor_set" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_scaleFactor_get" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_center_set" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_center_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_center_get" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_doAction" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_callback" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_GLRender" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_getMatrix" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture2Transform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture2Transform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture2Transform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture2Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture2Transform_pick" "', argument " "1"" of type '" "SoTexture2Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture2Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture2Transform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTexture2Transform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture2Transform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTexture2Transform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTexture3Transform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTexture3Transform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_getTypeId" "', argument " "1"" of type '" "SoTexture3Transform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = ((SoTexture3Transform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_initClass", 0, 0, 0)) SWIG_fail;
  SoTexture3Transform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTexture3Transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTexture3Transform", 0, 0, 0)) SWIG_fail;
  result = (SoTexture3Transform *)new SoTexture3Transform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTexture3Transform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_translation_set" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_translation_get" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_rotation_set" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_rotation_get" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_scaleFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_scaleFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_scaleFactor_set" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_scaleFactor_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scaleFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_scaleFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_scaleFactor_get" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scaleFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_scaleOrientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_scaleOrientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_scaleOrientation_set" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_scaleOrientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->scaleOrientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_scaleOrientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_scaleOrientation_get" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->scaleOrientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_center_set" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_center_get" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_doAction" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_callback" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_GLRender" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_getMatrix" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTexture3Transform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTexture3Transform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTexture3Transform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTexture3Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTexture3Transform_pick" "', argument " "1"" of type '" "SoTexture3Transform *""'"); 
  }
  arg1 = reinterpret_cast< SoTexture3Transform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTexture3Transform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTexture3Transform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTexture3Transform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTexture3Transform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinate2::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinate2 const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  result = ((SoTextureCoordinate2 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinate2::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinate2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinate2", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinate2 *)new SoTextureCoordinate2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinate2, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_point_set" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate2_point_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_point_get" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_doAction" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate2_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_GLRender" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate2_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_callback" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate2_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate2_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate2 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate2_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate2_pick" "', argument " "1"" of type '" "SoTextureCoordinate2 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate2_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinate2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinate2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinate2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinate3::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinate3 const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  result = ((SoTextureCoordinate3 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinate3::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinate3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinate3", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinate3 *)new SoTextureCoordinate3();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinate3, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_point_set" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate3_point_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_point_get" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_doAction" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate3_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_GLRender" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate3_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_callback" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate3_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinate3_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinate3 *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinate3_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinate3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinate3_pick" "', argument " "1"" of type '" "SoTextureCoordinate3 *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinate3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinate3_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinate3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinate3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinate3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateFunction_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateFunction_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateFunction::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateFunction_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateFunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateFunction_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateFunction const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateFunction * >(argp1);
  result = ((SoTextureCoordinateFunction const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateFunction_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateFunction_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateFunction::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateFunction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateFunction", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateFunction *)new SoTextureCoordinateFunction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateFunction, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateDefault::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateDefault, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateDefault_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateDefault const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateDefault * >(argp1);
  result = ((SoTextureCoordinateDefault const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateDefault::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateDefault", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateDefault *)new SoTextureCoordinateDefault();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateDefault, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateDefault, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateDefault_doAction" "', argument " "1"" of type '" "SoTextureCoordinateDefault *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateDefault * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateDefault_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateDefault, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateDefault_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateDefault *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateDefault * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateDefault_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateDefault, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateDefault_callback" "', argument " "1"" of type '" "SoTextureCoordinateDefault *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateDefault * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateDefault_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateDefault_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateDefault *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateDefault_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateDefault, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateDefault_pick" "', argument " "1"" of type '" "SoTextureCoordinateDefault *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateDefault * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateDefault_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateDefault_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateDefault, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateDefault_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateEnvironment::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateEnvironment_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateEnvironment const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateEnvironment * >(argp1);
  result = ((SoTextureCoordinateEnvironment const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateEnvironment::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateEnvironment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateEnvironment", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateEnvironment *)new SoTextureCoordinateEnvironment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateEnvironment, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateEnvironment_doAction" "', argument " "1"" of type '" "SoTextureCoordinateEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateEnvironment_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateEnvironment_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateEnvironment_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateEnvironment_pick" "', argument " "1"" of type '" "SoTextureCoordinateEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateEnvironment_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateEnvironment_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateEnvironment *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateEnvironment_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateEnvironment_callback" "', argument " "1"" of type '" "SoTextureCoordinateEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateEnvironment_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateEnvironment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateEnvironment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateEnvironment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinatePlane::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinatePlane const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  result = ((SoTextureCoordinatePlane const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinatePlane::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinatePlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinatePlane", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinatePlane *)new SoTextureCoordinatePlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinatePlane, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_directionS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionS_set" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_directionS_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->directionS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionS_get" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->directionS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_directionT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionT_set" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_directionT_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->directionT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionT_get" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->directionT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_directionR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionR_set" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_directionR_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->directionR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_directionR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_directionR_get" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->directionR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_doAction" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_GLRender" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_pick" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinatePlane_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinatePlane *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinatePlane_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinatePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinatePlane_callback" "', argument " "1"" of type '" "SoTextureCoordinatePlane *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinatePlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinatePlane_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinatePlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinatePlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinatePlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureMatrixTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_getTypeId" "', argument " "1"" of type '" "SoTextureMatrixTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  result = ((SoTextureMatrixTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureMatrixTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureMatrixTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureMatrixTransform", 0, 0, 0)) SWIG_fail;
  result = (SoTextureMatrixTransform *)new SoTextureMatrixTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureMatrixTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_matrix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_matrix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_matrix_set" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_matrix_set" "', argument " "2"" of type '" "SoSFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  if (arg1) (arg1)->matrix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_matrix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_matrix_get" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  result = (SoSFMatrix *)& ((arg1)->matrix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_doAction" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_callback" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_GLRender" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_getMatrix" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureMatrixTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureMatrixTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureMatrixTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureMatrixTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureMatrixTransform_pick" "', argument " "1"" of type '" "SoTextureMatrixTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureMatrixTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureMatrixTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureMatrixTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureMatrixTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureMatrixTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoWWWInline_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoWWWInline::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getTypeId" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = ((SoWWWInline const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_initClass", 0, 0, 0)) SWIG_fail;
  SoWWWInline::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoWWWInline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoWWWInline", 0, 0, 0)) SWIG_fail;
  result = (SoWWWInline *)new SoWWWInline();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoWWWInline, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_name_set" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_name_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_name_get" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoSFString *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_bboxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_bboxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_bboxCenter_set" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_bboxCenter_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_bboxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_bboxCenter_get" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_bboxSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_bboxSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_bboxSize_set" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_bboxSize_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_bboxSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_bboxSize_get" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_alternateRep_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_alternateRep_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_alternateRep_set" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_alternateRep_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->alternateRep = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_alternateRep_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_alternateRep_get" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoSFNode *)& ((arg1)->alternateRep);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_setFullURLName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_setFullURLName" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setFullURLName((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getFullURLName" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SbString *) &(arg1)->getFullURLName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_copyChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGroup *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_copyChildren" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoGroup *)((SoWWWInline const *)arg1)->copyChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGroup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_requestURLData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_requestURLData" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  (arg1)->requestURLData();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_isURLDataRequested(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_isURLDataRequested" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SbBool)((SoWWWInline const *)arg1)->isURLDataRequested();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_isURLDataHere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_isURLDataHere" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SbBool)((SoWWWInline const *)arg1)->isURLDataHere();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_cancelURLDataRequest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_cancelURLDataRequest" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  (arg1)->cancelURLDataRequest();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setChildData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_setChildData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_setChildData" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_setChildData" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setChildData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getChildData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getChildData" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoNode *)((SoWWWInline const *)arg1)->getChildData();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getChildren" "', argument " "1"" of type '" "SoWWWInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  result = (SoChildList *)((SoWWWInline const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setFetchURLCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInlineFetchURLCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_setFetchURLCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWInline__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoWWWInline_setFetchURLCallBack" "', argument " "1"" of type '" "SoWWWInlineFetchURLCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_setFetchURLCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoWWWInline::setFetchURLCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setBoundingBoxVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline::BboxVisibility arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoWWWInline_setBoundingBoxVisibility" "', argument " "1"" of type '" "SoWWWInline::BboxVisibility""'");
  } 
  arg1 = static_cast< SoWWWInline::BboxVisibility >(val1);
  SoWWWInline::setBoundingBoxVisibility(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getBoundingBoxVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline::BboxVisibility result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getBoundingBoxVisibility", 0, 0, 0)) SWIG_fail;
  result = (SoWWWInline::BboxVisibility)SoWWWInline::getBoundingBoxVisibility();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setBoundingBoxColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_setBoundingBoxColor" "', argument " "1"" of type '" "SbColor &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoWWWInline_setBoundingBoxColor" "', argument " "1"" of type '" "SbColor &""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  SoWWWInline::setBoundingBoxColor(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getBoundingBoxColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getBoundingBoxColor", 0, 0, 0)) SWIG_fail;
  result = (SbColor *) &SoWWWInline::getBoundingBoxColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_setReadAsSoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoWWWInline_setReadAsSoFile" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoWWWInline::setReadAsSoFile(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getReadAsSoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getReadAsSoFile", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoWWWInline::getReadAsSoFile();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_doAction" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_doActionOnKidsOrBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_doActionOnKidsOrBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_doActionOnKidsOrBox" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_doActionOnKidsOrBox" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doActionOnKidsOrBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_callback" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_GLRender" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getBoundingBox" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getMatrix" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_handleEvent" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_search" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_pick" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_getPrimitiveCount" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoWWWInline_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoWWWInline *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoWWWInline_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoWWWInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoWWWInline_audioRender" "', argument " "1"" of type '" "SoWWWInline *""'"); 
  }
  arg1 = reinterpret_cast< SoWWWInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoWWWInline_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoWWWInline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoWWWInline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoWWWInline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTransparencyType_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTransparencyType::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_getTypeId" "', argument " "1"" of type '" "SoTransparencyType const *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  result = ((SoTransparencyType const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_initClass", 0, 0, 0)) SWIG_fail;
  SoTransparencyType::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTransparencyType", 0, 0, 0)) SWIG_fail;
  result = (SoTransparencyType *)new SoTransparencyType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTransparencyType, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_value_set" "', argument " "1"" of type '" "SoTransparencyType *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyType_value_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_value_get" "', argument " "1"" of type '" "SoTransparencyType *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  result = (SoSFEnum *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_doAction" "', argument " "1"" of type '" "SoTransparencyType *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyType_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_GLRender" "', argument " "1"" of type '" "SoTransparencyType *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyType_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTransparencyType_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTransparencyType *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTransparencyType_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTransparencyType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTransparencyType_callback" "', argument " "1"" of type '" "SoTransparencyType *""'"); 
  }
  arg1 = reinterpret_cast< SoTransparencyType * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTransparencyType_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTransparencyType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTransparencyType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTransparencyType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateCube::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCube_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateCube const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCube * >(argp1);
  result = ((SoTextureCoordinateCube const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateCube::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateCube", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateCube *)new SoTextureCoordinateCube();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateCube, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCube_doAction" "', argument " "1"" of type '" "SoTextureCoordinateCube *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCube_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCube_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateCube *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCube_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCube_callback" "', argument " "1"" of type '" "SoTextureCoordinateCube *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCube_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCube_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCube *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCube_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCube, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCube_pick" "', argument " "1"" of type '" "SoTextureCoordinateCube *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCube * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCube_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateCube_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateCube, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateCube_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateSphere::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateSphere_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateSphere * >(argp1);
  result = ((SoTextureCoordinateSphere const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateSphere::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateSphere", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateSphere *)new SoTextureCoordinateSphere();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateSphere, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateSphere_doAction" "', argument " "1"" of type '" "SoTextureCoordinateSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateSphere_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateSphere_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateSphere_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateSphere_callback" "', argument " "1"" of type '" "SoTextureCoordinateSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateSphere_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateSphere_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateSphere *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateSphere_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateSphere_pick" "', argument " "1"" of type '" "SoTextureCoordinateSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateSphere_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateSphere_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateSphere, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateSphere_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateCylinder::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCylinder_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCylinder * >(argp1);
  result = ((SoTextureCoordinateCylinder const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateCylinder::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateCylinder", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateCylinder *)new SoTextureCoordinateCylinder();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateCylinder, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCylinder_doAction" "', argument " "1"" of type '" "SoTextureCoordinateCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCylinder_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCylinder_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCylinder_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCylinder_callback" "', argument " "1"" of type '" "SoTextureCoordinateCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCylinder_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateCylinder_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateCylinder *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateCylinder_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateCylinder_pick" "', argument " "1"" of type '" "SoTextureCoordinateCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateCylinder_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateCylinder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateCylinder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCubeMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCubeMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_getTypeId" "', argument " "1"" of type '" "SoTextureCubeMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = ((SoTextureCubeMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCubeMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCubeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCubeMap", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCubeMap *)new SoTextureCubeMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCubeMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_filenames_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_filenames_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_filenames_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_filenames_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->filenames = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_filenames_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_filenames_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoMFString *)& ((arg1)->filenames);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imagePosX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosX_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imagePosX_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imagePosX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosX_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imagePosX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegX_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imageNegX_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegX_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imageNegX_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imageNegX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegX_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegX_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imageNegX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imagePosY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosY_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imagePosY_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imagePosY = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosY_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imagePosY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegY_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imageNegY_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegY_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imageNegY_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imageNegY = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegY_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegY_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imageNegY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imagePosZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosZ_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imagePosZ_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imagePosZ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imagePosZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imagePosZ_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imagePosZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegZ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_imageNegZ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegZ_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_imageNegZ_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->imageNegZ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_imageNegZ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_imageNegZ_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFImage *)& ((arg1)->imageNegZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_wrapS_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_wrapS_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_wrapT_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_wrapT_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_model_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_model_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_blendColor_set" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_blendColor_get" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_doAction" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_GLRender" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_callback" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCubeMap *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCubeMap_rayPick" "', argument " "1"" of type '" "SoTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCubeMap_readImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  unsigned char **arg5 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCubeMap_readImage", 5, 5, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCubeMap_readImage" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCubeMap_readImage" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoTextureCubeMap_readImage" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCubeMap_readImage" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoTextureCubeMap_readImage" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCubeMap_readImage" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_unsigned_char,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoTextureCubeMap_readImage" "', argument " "5"" of type '" "unsigned char *&""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoTextureCubeMap_readImage" "', argument " "5"" of type '" "unsigned char *&""'"); 
  }
  arg5 = reinterpret_cast< unsigned char ** >(argp5);
  result = (SbBool)SoTextureCubeMap::readImage((SbString const &)*arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoTextureCubeMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCubeMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCubeMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderObject_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderObject::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_getTypeId" "', argument " "1"" of type '" "SoShaderObject const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = ((SoShaderObject const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_isActive_set" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_isActive_get" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_sourceType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_sourceType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_sourceType_set" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_sourceType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->sourceType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_sourceType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_sourceType_get" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = (SoSFEnum *)& ((arg1)->sourceType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_sourceProgram_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_sourceProgram_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_sourceProgram_set" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_sourceProgram_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->sourceProgram = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_sourceProgram_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_sourceProgram_get" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = (SoSFString *)& ((arg1)->sourceProgram);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_parameter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_parameter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_parameter_set" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_parameter_set" "', argument " "2"" of type '" "SoMFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  if (arg1) (arg1)->parameter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_parameter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_parameter_get" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = (SoMFNode *)& ((arg1)->parameter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderObject::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_GLRender" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_search" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_render(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_render", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_render" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_render" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_updateParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderObject_updateParameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_updateParameters" "', argument " "1"" of type '" "SoShaderObject *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderObject_updateParameters" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->updateParameters(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_getSourceType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoShaderObject::SourceType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_getSourceType" "', argument " "1"" of type '" "SoShaderObject const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = (SoShaderObject::SourceType)((SoShaderObject const *)arg1)->getSourceType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderObject_getSourceProgram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderObject_getSourceProgram" "', argument " "1"" of type '" "SoShaderObject const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderObject * >(argp1);
  result = ((SoShaderObject const *)arg1)->getSourceProgram();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoShaderParameter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter_getTypeId" "', argument " "1"" of type '" "SoShaderParameter const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter * >(argp1);
  result = ((SoShaderParameter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter_name_set" "', argument " "1"" of type '" "SoShaderParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter_name_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter_name_get" "', argument " "1"" of type '" "SoShaderParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter * >(argp1);
  result = (SoSFString *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_identifier_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter_identifier_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter_identifier_set" "', argument " "1"" of type '" "SoShaderParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter_identifier_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->identifier = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_identifier_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter_identifier_get" "', argument " "1"" of type '" "SoShaderParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->identifier);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoUniformShaderParameter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUniformShaderParameter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoUniformShaderParameter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUniformShaderParameter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUniformShaderParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUniformShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUniformShaderParameter_getTypeId" "', argument " "1"" of type '" "SoUniformShaderParameter const *""'"); 
  }
  arg1 = reinterpret_cast< SoUniformShaderParameter * >(argp1);
  result = ((SoUniformShaderParameter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUniformShaderParameter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUniformShaderParameter_initClass", 0, 0, 0)) SWIG_fail;
  SoUniformShaderParameter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoUniformShaderParameter_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoUniformShaderParameter *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoUniformShaderParameter_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoUniformShaderParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoUniformShaderParameter_updateParameter" "', argument " "1"" of type '" "SoUniformShaderParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoUniformShaderParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoUniformShaderParameter_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoUniformShaderParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoUniformShaderParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoShaderParameter1f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter1f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1f_getTypeId" "', argument " "1"" of type '" "SoShaderParameter1f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1f * >(argp1);
  result = ((SoShaderParameter1f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1f *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1f_value_set" "', argument " "1"" of type '" "SoShaderParameter1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter1f_value_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1f_value_get" "', argument " "1"" of type '" "SoShaderParameter1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1f * >(argp1);
  result = (SoSFFloat *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter1f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter1f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter1f *)new SoShaderParameter1f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter1f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter1f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1f_updateParameter" "', argument " "1"" of type '" "SoShaderParameter1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter1f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter1f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter1f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter1f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter1i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter1i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1i_getTypeId" "', argument " "1"" of type '" "SoShaderParameter1i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1i * >(argp1);
  result = ((SoShaderParameter1i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1i *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1i_value_set" "', argument " "1"" of type '" "SoShaderParameter1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter1i_value_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1i_value_get" "', argument " "1"" of type '" "SoShaderParameter1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1i * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter1i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter1i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter1i *)new SoShaderParameter1i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter1i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter1i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter1i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter1i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter1i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter1i_updateParameter" "', argument " "1"" of type '" "SoShaderParameter1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter1i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter1i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter1i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter1i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter1i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2f_getTypeId" "', argument " "1"" of type '" "SoShaderParameter2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2f * >(argp1);
  result = ((SoShaderParameter2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2f *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2f_value_set" "', argument " "1"" of type '" "SoShaderParameter2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter2f_value_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2f_value_get" "', argument " "1"" of type '" "SoShaderParameter2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2f * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter2f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter2f *)new SoShaderParameter2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter2f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2f_updateParameter" "', argument " "1"" of type '" "SoShaderParameter2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter2f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter2i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter2i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2i_getTypeId" "', argument " "1"" of type '" "SoShaderParameter2i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2i * >(argp1);
  result = ((SoShaderParameter2i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2i *arg1 = 0 ;
  SoSFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2i_value_set" "', argument " "1"" of type '" "SoShaderParameter2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter2i_value_set" "', argument " "2"" of type '" "SoSFVec2i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2i_value_get" "', argument " "1"" of type '" "SoShaderParameter2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2i * >(argp1);
  result = (SoSFVec2i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter2i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter2i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter2i *)new SoShaderParameter2i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter2i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter2i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter2i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter2i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter2i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter2i_updateParameter" "', argument " "1"" of type '" "SoShaderParameter2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter2i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter2i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter2i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter2i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter2i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3f_getTypeId" "', argument " "1"" of type '" "SoShaderParameter3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3f * >(argp1);
  result = ((SoShaderParameter3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3f *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3f_value_set" "', argument " "1"" of type '" "SoShaderParameter3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter3f_value_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3f_value_get" "', argument " "1"" of type '" "SoShaderParameter3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3f * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter3f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter3f *)new SoShaderParameter3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3f_updateParameter" "', argument " "1"" of type '" "SoShaderParameter3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter3f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter3i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter3i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3i_getTypeId" "', argument " "1"" of type '" "SoShaderParameter3i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3i * >(argp1);
  result = ((SoShaderParameter3i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3i *arg1 = 0 ;
  SoSFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3i_value_set" "', argument " "1"" of type '" "SoShaderParameter3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter3i_value_set" "', argument " "2"" of type '" "SoSFVec3i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3i_value_get" "', argument " "1"" of type '" "SoShaderParameter3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3i * >(argp1);
  result = (SoSFVec3i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter3i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter3i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter3i *)new SoShaderParameter3i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter3i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter3i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter3i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter3i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter3i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter3i_updateParameter" "', argument " "1"" of type '" "SoShaderParameter3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter3i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter3i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter3i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter3i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter3i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4f_getTypeId" "', argument " "1"" of type '" "SoShaderParameter4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4f * >(argp1);
  result = ((SoShaderParameter4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4f *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4f_value_set" "', argument " "1"" of type '" "SoShaderParameter4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter4f_value_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4f_value_get" "', argument " "1"" of type '" "SoShaderParameter4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4f * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter4f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter4f *)new SoShaderParameter4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter4f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4f_updateParameter" "', argument " "1"" of type '" "SoShaderParameter4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter4f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameter4i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameter4i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4i_getTypeId" "', argument " "1"" of type '" "SoShaderParameter4i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4i * >(argp1);
  result = ((SoShaderParameter4i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4i *arg1 = 0 ;
  SoSFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4i_value_set" "', argument " "1"" of type '" "SoShaderParameter4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter4i_value_set" "', argument " "2"" of type '" "SoSFVec4i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4i_value_get" "', argument " "1"" of type '" "SoShaderParameter4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4i * >(argp1);
  result = (SoSFVec4i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameter4i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameter4i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameter4i *)new SoShaderParameter4i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameter4i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameter4i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameter4i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameter4i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameter4i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameter4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameter4i_updateParameter" "', argument " "1"" of type '" "SoShaderParameter4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameter4i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameter4i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameter4i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameter4i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameter4i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray1f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1f_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray1f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1f * >(argp1);
  result = ((SoShaderParameterArray1f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1f *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1f_value_set" "', argument " "1"" of type '" "SoShaderParameterArray1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray1f_value_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1f_value_get" "', argument " "1"" of type '" "SoShaderParameterArray1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1f * >(argp1);
  result = (SoMFFloat *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray1f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray1f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray1f *)new SoShaderParameterArray1f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray1f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray1f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1f_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray1f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray1f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray1f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray1f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray1f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray1i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1i_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray1i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1i * >(argp1);
  result = ((SoShaderParameterArray1i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1i *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1i_value_set" "', argument " "1"" of type '" "SoShaderParameterArray1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray1i_value_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1i_value_get" "', argument " "1"" of type '" "SoShaderParameterArray1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1i * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray1i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray1i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray1i *)new SoShaderParameterArray1i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray1i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray1i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray1i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray1i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray1i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray1i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray1i_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray1i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray1i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray1i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray1i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray1i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray1i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray2f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2f_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray2f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2f * >(argp1);
  result = ((SoShaderParameterArray2f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2f *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2f_value_set" "', argument " "1"" of type '" "SoShaderParameterArray2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray2f_value_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2f_value_get" "', argument " "1"" of type '" "SoShaderParameterArray2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2f * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray2f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray2f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray2f *)new SoShaderParameterArray2f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray2f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray2f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2f_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray2f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray2f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray2f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray2f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray2i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2i_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray2i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2i * >(argp1);
  result = ((SoShaderParameterArray2i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2i *arg1 = 0 ;
  SoMFVec2i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2i_value_set" "', argument " "1"" of type '" "SoShaderParameterArray2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray2i_value_set" "', argument " "2"" of type '" "SoMFVec2i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2i_value_get" "', argument " "1"" of type '" "SoShaderParameterArray2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2i * >(argp1);
  result = (SoMFVec2i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray2i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray2i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray2i *)new SoShaderParameterArray2i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray2i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray2i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray2i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray2i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray2i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray2i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray2i_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray2i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray2i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray2i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray2i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray2i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray2i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray3f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3f_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray3f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3f * >(argp1);
  result = ((SoShaderParameterArray3f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3f *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3f_value_set" "', argument " "1"" of type '" "SoShaderParameterArray3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray3f_value_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3f_value_get" "', argument " "1"" of type '" "SoShaderParameterArray3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3f * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray3f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray3f *)new SoShaderParameterArray3f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray3f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray3f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3f_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray3f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray3f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray3f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray3f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray3i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3i_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray3i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3i * >(argp1);
  result = ((SoShaderParameterArray3i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3i *arg1 = 0 ;
  SoMFVec3i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3i_value_set" "', argument " "1"" of type '" "SoShaderParameterArray3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray3i_value_set" "', argument " "2"" of type '" "SoMFVec3i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3i_value_get" "', argument " "1"" of type '" "SoShaderParameterArray3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3i * >(argp1);
  result = (SoMFVec3i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray3i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray3i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray3i *)new SoShaderParameterArray3i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray3i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray3i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray3i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray3i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray3i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray3i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray3i_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray3i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray3i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray3i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray3i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray3i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray3i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4f_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray4f::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4f_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray4f const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4f * >(argp1);
  result = ((SoShaderParameterArray4f const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4f *arg1 = 0 ;
  SoMFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4f_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4f_value_set" "', argument " "1"" of type '" "SoShaderParameterArray4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray4f_value_set" "', argument " "2"" of type '" "SoMFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4f * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4f *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4f_value_get" "', argument " "1"" of type '" "SoShaderParameterArray4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4f * >(argp1);
  result = (SoMFVec4f *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray4f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4f *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray4f", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray4f *)new SoShaderParameterArray4f();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray4f, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4f_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray4f::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4f_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4f *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4f_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4f_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray4f *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray4f_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray4f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray4f, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray4f_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4i_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterArray4i::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4i_getTypeId" "', argument " "1"" of type '" "SoShaderParameterArray4i const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4i * >(argp1);
  result = ((SoShaderParameterArray4i const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4i *arg1 = 0 ;
  SoMFVec4i32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4i_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4i_value_set" "', argument " "1"" of type '" "SoShaderParameterArray4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray4i_value_set" "', argument " "2"" of type '" "SoMFVec4i32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec4i32 * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4i *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec4i32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4i_value_get" "', argument " "1"" of type '" "SoShaderParameterArray4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4i * >(argp1);
  result = (SoMFVec4i32 *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec4i32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterArray4i(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4i *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterArray4i", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterArray4i *)new SoShaderParameterArray4i();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterArray4i, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4i_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterArray4i::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterArray4i_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterArray4i *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterArray4i_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterArray4i, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterArray4i_updateParameter" "', argument " "1"" of type '" "SoShaderParameterArray4i *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterArray4i * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterArray4i_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterArray4i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterArray4i, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterArray4i_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrix_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterMatrix::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrix_getTypeId" "', argument " "1"" of type '" "SoShaderParameterMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrix * >(argp1);
  result = ((SoShaderParameterMatrix const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrix *arg1 = 0 ;
  SoSFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrix_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrix_value_set" "', argument " "1"" of type '" "SoShaderParameterMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterMatrix_value_set" "', argument " "2"" of type '" "SoSFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoSFMatrix * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrix_value_get" "', argument " "1"" of type '" "SoShaderParameterMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrix * >(argp1);
  result = (SoSFMatrix *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrix *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterMatrix", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterMatrix *)new SoShaderParameterMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterMatrix, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrix_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterMatrix::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrix_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrix *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrix_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrix_updateParameter" "', argument " "1"" of type '" "SoShaderParameterMatrix *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterMatrix_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrixArray_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderParameterMatrixArray::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrixArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrixArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrixArray_getTypeId" "', argument " "1"" of type '" "SoShaderParameterMatrixArray const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrixArray * >(argp1);
  result = ((SoShaderParameterMatrixArray const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrixArray *arg1 = 0 ;
  SoMFMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrixArray_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrixArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrixArray_value_set" "', argument " "1"" of type '" "SoShaderParameterMatrixArray *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrixArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterMatrixArray_value_set" "', argument " "2"" of type '" "SoMFMatrix *""'"); 
  }
  arg2 = reinterpret_cast< SoMFMatrix * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrixArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrixArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrixArray_value_get" "', argument " "1"" of type '" "SoShaderParameterMatrixArray *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrixArray * >(argp1);
  result = (SoMFMatrix *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderParameterMatrixArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrixArray *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderParameterMatrixArray", 0, 0, 0)) SWIG_fail;
  result = (SoShaderParameterMatrixArray *)new SoShaderParameterMatrixArray();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderParameterMatrixArray, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrixArray_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderParameterMatrixArray::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderParameterMatrixArray_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderParameterMatrixArray *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderParameterMatrixArray_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderParameterMatrixArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderParameterMatrixArray_updateParameter" "', argument " "1"" of type '" "SoShaderParameterMatrixArray *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderParameterMatrixArray * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderParameterMatrixArray_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderParameterMatrixArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderParameterMatrixArray, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderParameterMatrixArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderStateMatrixParameter::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_getTypeId" "', argument " "1"" of type '" "SoShaderStateMatrixParameter const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  result = ((SoShaderStateMatrixParameter const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_matrixType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_matrixType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_matrixType_set" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderStateMatrixParameter_matrixType_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->matrixType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_matrixType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_matrixType_get" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  result = (SoSFEnum *)& ((arg1)->matrixType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_matrixTransform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_matrixTransform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_matrixTransform_set" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderStateMatrixParameter_matrixTransform_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->matrixTransform = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_matrixTransform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_matrixTransform_get" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  result = (SoSFEnum *)& ((arg1)->matrixTransform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderStateMatrixParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderStateMatrixParameter", 0, 0, 0)) SWIG_fail;
  result = (SoShaderStateMatrixParameter *)new SoShaderStateMatrixParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderStateMatrixParameter, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoShaderStateMatrixParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoShaderStateMatrixParameter" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  arg1->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderStateMatrixParameter::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_updateParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  SoGLShaderObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_updateParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_updateParameter" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLShaderObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderStateMatrixParameter_updateParameter" "', argument " "2"" of type '" "SoGLShaderObject *""'"); 
  }
  arg2 = reinterpret_cast< SoGLShaderObject * >(argp2);
  (arg1)->updateParameter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderStateMatrixParameter_updateValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderStateMatrixParameter *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderStateMatrixParameter_updateValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderStateMatrixParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderStateMatrixParameter_updateValue" "', argument " "1"" of type '" "SoShaderStateMatrixParameter *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderStateMatrixParameter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderStateMatrixParameter_updateValue" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->updateValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderStateMatrixParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderStateMatrixParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderStateMatrixParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoShaderProgram_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoShaderProgram::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_getTypeId" "', argument " "1"" of type '" "SoShaderProgram const *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  result = ((SoShaderProgram const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_shaderObject_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_shaderObject_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_shaderObject_set" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderProgram_shaderObject_set" "', argument " "2"" of type '" "SoMFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  if (arg1) (arg1)->shaderObject = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_shaderObject_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_shaderObject_get" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  result = (SoMFNode *)& ((arg1)->shaderObject);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoShaderProgram(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoShaderProgram", 0, 0, 0)) SWIG_fail;
  result = (SoShaderProgram *)new SoShaderProgram();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoShaderProgram, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_setEnableCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  SoShaderProgramEnableCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_setEnableCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_setEnableCallback" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoState_q_const__int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoShaderProgram_setEnableCallback" "', argument " "2"" of type '" "SoShaderProgramEnableCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoShaderProgram_setEnableCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setEnableCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_GLRender" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderProgram_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_search" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderProgram_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_render(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderProgram *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_render", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoShaderProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoShaderProgram_render" "', argument " "1"" of type '" "SoShaderProgram *""'"); 
  }
  arg1 = reinterpret_cast< SoShaderProgram * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoShaderProgram_render" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoShaderProgram_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoShaderProgram_initClass", 0, 0, 0)) SWIG_fail;
  SoShaderProgram::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoShaderProgram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoShaderProgram, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoShaderProgram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoFragmentShader_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFragmentShader_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoFragmentShader::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFragmentShader_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFragmentShader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFragmentShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoFragmentShader_getTypeId" "', argument " "1"" of type '" "SoFragmentShader const *""'"); 
  }
  arg1 = reinterpret_cast< SoFragmentShader * >(argp1);
  result = ((SoFragmentShader const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFragmentShader_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoFragmentShader_initClass", 0, 0, 0)) SWIG_fail;
  SoFragmentShader::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoFragmentShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFragmentShader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoFragmentShader", 0, 0, 0)) SWIG_fail;
  result = (SoFragmentShader *)new SoFragmentShader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoFragmentShader, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoFragmentShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoFragmentShader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoFragmentShader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoFragmentShader" "', argument " "1"" of type '" "SoFragmentShader *""'"); 
  }
  arg1 = reinterpret_cast< SoFragmentShader * >(argp1);
  arg1->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoFragmentShader_isSupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject::SourceType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoFragmentShader_isSupported" "', argument " "1"" of type '" "SoShaderObject::SourceType""'");
  } 
  arg1 = static_cast< SoShaderObject::SourceType >(val1);
  result = (SbBool)SoFragmentShader::isSupported(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoFragmentShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoFragmentShader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoFragmentShader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVertexShader_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShader_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVertexShader::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShader_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVertexShader_getTypeId" "', argument " "1"" of type '" "SoVertexShader const *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShader * >(argp1);
  result = ((SoVertexShader const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShader_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVertexShader_initClass", 0, 0, 0)) SWIG_fail;
  SoVertexShader::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVertexShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVertexShader", 0, 0, 0)) SWIG_fail;
  result = (SoVertexShader *)new SoVertexShader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVertexShader, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoVertexShader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVertexShader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVertexShader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoVertexShader" "', argument " "1"" of type '" "SoVertexShader *""'"); 
  }
  arg1 = reinterpret_cast< SoVertexShader * >(argp1);
  arg1->unref();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVertexShader_isSupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoShaderObject::SourceType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVertexShader_isSupported" "', argument " "1"" of type '" "SoShaderObject::SourceType""'");
  } 
  arg1 = static_cast< SoShaderObject::SourceType >(val1);
  result = (SbBool)SoVertexShader::isSupported(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVertexShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVertexShader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVertexShader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateNormalMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateNormalMap_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateNormalMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateNormalMap * >(argp1);
  result = ((SoTextureCoordinateNormalMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateNormalMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateNormalMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateNormalMap", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateNormalMap *)new SoTextureCoordinateNormalMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateNormalMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateNormalMap_doAction" "', argument " "1"" of type '" "SoTextureCoordinateNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateNormalMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateNormalMap_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateNormalMap_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateNormalMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateNormalMap_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateNormalMap_pick" "', argument " "1"" of type '" "SoTextureCoordinateNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateNormalMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateNormalMap_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateNormalMap_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateNormalMap *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateNormalMap_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateNormalMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateNormalMap_callback" "', argument " "1"" of type '" "SoTextureCoordinateNormalMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateNormalMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateNormalMap_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateNormalMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateNormalMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateNormalMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateReflectionMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateReflectionMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateReflectionMap_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateReflectionMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateReflectionMap * >(argp1);
  result = ((SoTextureCoordinateReflectionMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateReflectionMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateReflectionMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateReflectionMap", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateReflectionMap *)new SoTextureCoordinateReflectionMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateReflectionMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateReflectionMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateReflectionMap_doAction" "', argument " "1"" of type '" "SoTextureCoordinateReflectionMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateReflectionMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateReflectionMap_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateReflectionMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateReflectionMap_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateReflectionMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateReflectionMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateReflectionMap_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateReflectionMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateReflectionMap_pick" "', argument " "1"" of type '" "SoTextureCoordinateReflectionMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateReflectionMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateReflectionMap_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateReflectionMap_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateReflectionMap *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateReflectionMap_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateReflectionMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateReflectionMap_callback" "', argument " "1"" of type '" "SoTextureCoordinateReflectionMap *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateReflectionMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateReflectionMap_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateReflectionMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateReflectionMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateReflectionMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCoordinateObject::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_getTypeId" "', argument " "1"" of type '" "SoTextureCoordinateObject const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  result = ((SoTextureCoordinateObject const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCoordinateObject::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCoordinateObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCoordinateObject", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCoordinateObject *)new SoTextureCoordinateObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCoordinateObject, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_factorS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorS_set" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_factorS_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->factorS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorS_get" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->factorS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_factorT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorT_set" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_factorT_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->factorT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorT_get" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->factorT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_factorR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorR_set" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_factorR_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->factorR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorR_get" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->factorR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorQ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_factorQ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorQ_set" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_factorQ_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->factorQ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_factorQ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_factorQ_get" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->factorQ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_doAction" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_GLRender" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_pick" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCoordinateObject_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCoordinateObject *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCoordinateObject_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCoordinateObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCoordinateObject_callback" "', argument " "1"" of type '" "SoTextureCoordinateObject *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCoordinateObject * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCoordinateObject_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCoordinateObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCoordinateObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCoordinateObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureScalePolicy_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureScalePolicy::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_getTypeId" "', argument " "1"" of type '" "SoTextureScalePolicy const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  result = ((SoTextureScalePolicy const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureScalePolicy_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureScalePolicy::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureScalePolicy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureScalePolicy", 0, 0, 0)) SWIG_fail;
  result = (SoTextureScalePolicy *)new SoTextureScalePolicy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureScalePolicy, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_policy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureScalePolicy_policy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_policy_set" "', argument " "1"" of type '" "SoTextureScalePolicy *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureScalePolicy_policy_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->policy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_policy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_policy_get" "', argument " "1"" of type '" "SoTextureScalePolicy *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  result = (SoSFEnum *)& ((arg1)->policy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_quality_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureScalePolicy_quality_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_quality_set" "', argument " "1"" of type '" "SoTextureScalePolicy *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureScalePolicy_quality_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->quality = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_quality_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_quality_get" "', argument " "1"" of type '" "SoTextureScalePolicy *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  result = (SoSFFloat *)& ((arg1)->quality);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureScalePolicy_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureScalePolicy *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureScalePolicy_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureScalePolicy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureScalePolicy_GLRender" "', argument " "1"" of type '" "SoTextureScalePolicy *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureScalePolicy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureScalePolicy_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureScalePolicy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureScalePolicy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureScalePolicy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureUnit_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureUnit::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_getTypeId" "', argument " "1"" of type '" "SoTextureUnit const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  result = ((SoTextureUnit const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureUnit::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureUnit", 0, 0, 0)) SWIG_fail;
  result = (SoTextureUnit *)new SoTextureUnit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureUnit, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_unit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_unit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_unit_set" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_unit_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->unit = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_unit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_unit_get" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->unit);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_mappingMethod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_mappingMethod_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_mappingMethod_set" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_mappingMethod_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->mappingMethod = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_mappingMethod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_mappingMethod_get" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  result = (SoSFEnum *)& ((arg1)->mappingMethod);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_doAction" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_callback" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_GLRender" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_pick" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_getBoundingBox" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureUnit *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureUnit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureUnit_getMatrix" "', argument " "1"" of type '" "SoTextureUnit *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureUnit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureUnit_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureUnit_getMaxTextureUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureUnit_getMaxTextureUnit", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoTextureUnit::getMaxTextureUnit();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureUnit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoTextureCombine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoTextureCombine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_getTypeId" "', argument " "1"" of type '" "SoTextureCombine const *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = ((SoTextureCombine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_initClass", 0, 0, 0)) SWIG_fail;
  SoTextureCombine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTextureCombine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTextureCombine", 0, 0, 0)) SWIG_fail;
  result = (SoTextureCombine *)new SoTextureCombine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTextureCombine, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbSource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_rgbSource_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbSource_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_rgbSource_set" "', argument " "2"" of type '" "SoMFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  if (arg1) (arg1)->rgbSource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbSource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbSource_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoMFEnum *)& ((arg1)->rgbSource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaSource_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_alphaSource_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaSource_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_alphaSource_set" "', argument " "2"" of type '" "SoMFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  if (arg1) (arg1)->alphaSource = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaSource_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaSource_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoMFEnum *)& ((arg1)->alphaSource);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbOperand_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_rgbOperand_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbOperand_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_rgbOperand_set" "', argument " "2"" of type '" "SoMFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  if (arg1) (arg1)->rgbOperand = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbOperand_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbOperand_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoMFEnum *)& ((arg1)->rgbOperand);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaOperand_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoMFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_alphaOperand_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaOperand_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_alphaOperand_set" "', argument " "2"" of type '" "SoMFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoMFEnum * >(argp2);
  if (arg1) (arg1)->alphaOperand = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaOperand_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaOperand_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoMFEnum *)& ((arg1)->alphaOperand);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_rgbOperation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbOperation_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_rgbOperation_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->rgbOperation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbOperation_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoSFEnum *)& ((arg1)->rgbOperation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaOperation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_alphaOperation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaOperation_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_alphaOperation_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->alphaOperation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaOperation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaOperation_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoSFEnum *)& ((arg1)->alphaOperation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbScale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_rgbScale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbScale_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_rgbScale_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->rgbScale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_rgbScale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_rgbScale_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoSFFloat *)& ((arg1)->rgbScale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaScale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_alphaScale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaScale_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_alphaScale_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->alphaScale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_alphaScale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_alphaScale_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoSFFloat *)& ((arg1)->alphaScale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_constantColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_constantColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_constantColor_set" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_constantColor_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->constantColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_constantColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_constantColor_get" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->constantColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_doAction" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_callback" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_GLRender" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTextureCombine_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTextureCombine *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTextureCombine_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTextureCombine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTextureCombine_pick" "', argument " "1"" of type '" "SoTextureCombine *""'"); 
  }
  arg1 = reinterpret_cast< SoTextureCombine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoTextureCombine_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTextureCombine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTextureCombine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTextureCombine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSceneTexture2_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSceneTexture2::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_getTypeId" "', argument " "1"" of type '" "SoSceneTexture2 const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = ((SoSceneTexture2 const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_initClass", 0, 0, 0)) SWIG_fail;
  SoSceneTexture2::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSceneTexture2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSceneTexture2", 0, 0, 0)) SWIG_fail;
  result = (SoSceneTexture2 *)new SoSceneTexture2();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneTexture2, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_wrapS_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_wrapS_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_wrapT_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_wrapT_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_model_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_model_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_blendColor_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_blendColor_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_backgroundColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_backgroundColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_backgroundColor_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_backgroundColor_set" "', argument " "2"" of type '" "SoSFVec4f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec4f * >(argp2);
  if (arg1) (arg1)->backgroundColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_backgroundColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_backgroundColor_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFVec4f *)& ((arg1)->backgroundColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_size_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_size_set" "', argument " "2"" of type '" "SoSFVec2s *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2s * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_size_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFVec2s *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_scene_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_scene_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_scene_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_scene_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->scene = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_scene_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_scene_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFNode *)& ((arg1)->scene);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_sceneTransparencyType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_sceneTransparencyType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_sceneTransparencyType_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_sceneTransparencyType_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->sceneTransparencyType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_sceneTransparencyType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_sceneTransparencyType_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFNode *)& ((arg1)->sceneTransparencyType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_transparencyFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_transparencyFunction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_transparencyFunction_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_transparencyFunction_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->transparencyFunction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_transparencyFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_transparencyFunction_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->transparencyFunction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_type_set" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_type_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_type_get" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  result = (SoSFEnum *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_notify" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_write" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_doAction" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_GLRender" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_callback" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTexture2_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTexture2 *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTexture2_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTexture2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTexture2_rayPick" "', argument " "1"" of type '" "SoSceneTexture2 *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTexture2 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTexture2_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSceneTexture2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSceneTexture2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSceneTexture2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoSceneTextureCubeMap::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_getTypeId" "', argument " "1"" of type '" "SoSceneTextureCubeMap const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = ((SoSceneTextureCubeMap const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_initClass", 0, 0, 0)) SWIG_fail;
  SoSceneTextureCubeMap::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoSceneTextureCubeMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSceneTextureCubeMap", 0, 0, 0)) SWIG_fail;
  result = (SoSceneTextureCubeMap *)new SoSceneTextureCubeMap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneTextureCubeMap, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_size_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_size_set" "', argument " "2"" of type '" "SoSFVec2s *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2s * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_size_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFVec2s *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_scene_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_scene_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_scene_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_scene_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->scene = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_scene_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_scene_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFNode *)& ((arg1)->scene);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_wrapS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapS_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_wrapS_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapS_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_wrapT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapT_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_wrapT_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapT_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_wrapR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapR_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_wrapR_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->wrapR = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_wrapR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_wrapR_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->wrapR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_model_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_model_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_backgroundColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_backgroundColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_backgroundColor_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_backgroundColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->backgroundColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_backgroundColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_backgroundColor_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFColor *)& ((arg1)->backgroundColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_transparencyFunction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_transparencyFunction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_transparencyFunction_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_transparencyFunction_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->transparencyFunction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_transparencyFunction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_transparencyFunction_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFEnum *)& ((arg1)->transparencyFunction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_blendColor_set" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_blendColor_get" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_doAction" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_GLRender" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_callback" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneTextureCubeMap_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneTextureCubeMap *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneTextureCubeMap_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneTextureCubeMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneTextureCubeMap_rayPick" "', argument " "1"" of type '" "SoSceneTextureCubeMap *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneTextureCubeMap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneTextureCubeMap_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoSceneTextureCubeMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSceneTextureCubeMap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSceneTextureCubeMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoCacheHintElement_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCacheHintElement::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_getClassStackIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_getClassStackIndex", 0, 0, 0)) SWIG_fail;
  result = (int)SoCacheHintElement::getClassStackIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoCacheHintElement::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_initClass", 0, 0, 0)) SWIG_fail;
  SoCacheHintElement::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHintElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_init" "', argument " "1"" of type '" "SoCacheHintElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_init" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_push(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHintElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_push", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_push" "', argument " "1"" of type '" "SoCacheHintElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_push" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  (arg1)->push(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHintElement *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoElement *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_pop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_pop" "', argument " "1"" of type '" "SoCacheHintElement *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_pop" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCacheHintElement_pop" "', argument " "3"" of type '" "SoElement const *""'"); 
  }
  arg3 = reinterpret_cast< SoElement * >(argp3);
  (arg1)->pop(arg2,(SoElement const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_matches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHintElement *arg1 = 0 ;
  SoElement *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_matches", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_matches" "', argument " "1"" of type '" "SoCacheHintElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHintElement * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_matches" "', argument " "2"" of type '" "SoElement const *""'"); 
  }
  arg2 = reinterpret_cast< SoElement * >(argp2);
  result = (SbBool)((SoCacheHintElement const *)arg1)->matches((SoElement const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_copyMatchInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHintElement *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoElement *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHintElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_copyMatchInfo" "', argument " "1"" of type '" "SoCacheHintElement const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHintElement * >(argp1);
  result = (SoElement *)((SoCacheHintElement const *)arg1)->copyMatchInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_set" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_set" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoCacheHintElement_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoCacheHintElement_set" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  SoCacheHintElement::set(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHintElement_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoState *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHintElement_get", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHintElement_get" "', argument " "1"" of type '" "SoState *""'"); 
  }
  arg1 = reinterpret_cast< SoState * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHintElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCacheHintElement_get" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoCacheHintElement_get" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoCacheHintElement_get" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  SoCacheHintElement::get(arg1,*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCacheHintElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCacheHintElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoCacheHint_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoCacheHint::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_getTypeId" "', argument " "1"" of type '" "SoCacheHint const *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  result = ((SoCacheHint const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_initClass", 0, 0, 0)) SWIG_fail;
  SoCacheHint::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoCacheHint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoCacheHint", 0, 0, 0)) SWIG_fail;
  result = (SoCacheHint *)new SoCacheHint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCacheHint, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_memValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_memValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_memValue_set" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_memValue_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->memValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_memValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_memValue_get" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  result = (SoSFFloat *)& ((arg1)->memValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_gfxValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_gfxValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_gfxValue_set" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_gfxValue_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->gfxValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_gfxValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_gfxValue_get" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  result = (SoSFFloat *)& ((arg1)->gfxValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_doAction" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_GLRender" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_callback" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_getBoundingBox" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoCacheHint_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCacheHint *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoCacheHint_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCacheHint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoCacheHint_pick" "', argument " "1"" of type '" "SoCacheHint *""'"); 
  }
  arg1 = reinterpret_cast< SoCacheHint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoCacheHint_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoCacheHint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoCacheHint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoCacheHint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoDepthBuffer_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoDepthBuffer::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_getTypeId" "', argument " "1"" of type '" "SoDepthBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  result = ((SoDepthBuffer const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_initClass", 0, 0, 0)) SWIG_fail;
  SoDepthBuffer::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoDepthBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoDepthBuffer", 0, 0, 0)) SWIG_fail;
  result = (SoDepthBuffer *)new SoDepthBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDepthBuffer, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_test_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_test_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_test_set" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBuffer_test_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->test = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_test_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_test_get" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  result = (SoSFBool *)& ((arg1)->test);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_write_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_write_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_write_set" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBuffer_write_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->write = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_write_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_write_get" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  result = (SoSFBool *)& ((arg1)->write);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_function_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_function_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_function_set" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBuffer_function_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->function = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_function_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_function_get" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  result = (SoSFEnum *)& ((arg1)->function);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_range_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_range_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_range_set" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBuffer_range_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->range = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_range_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_range_get" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->range);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoDepthBuffer_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoDepthBuffer *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoDepthBuffer_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoDepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoDepthBuffer_GLRender" "', argument " "1"" of type '" "SoDepthBuffer *""'"); 
  }
  arg1 = reinterpret_cast< SoDepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoDepthBuffer_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoDepthBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoDepthBuffer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoDepthBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoAlphaTest_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlphaTest_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoAlphaTest::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_getTypeId" "', argument " "1"" of type '" "SoAlphaTest const *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  result = ((SoAlphaTest const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlphaTest_initClass", 0, 0, 0)) SWIG_fail;
  SoAlphaTest::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAlphaTest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAlphaTest", 0, 0, 0)) SWIG_fail;
  result = (SoAlphaTest *)new SoAlphaTest();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAlphaTest, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_function_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlphaTest_function_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_function_set" "', argument " "1"" of type '" "SoAlphaTest *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAlphaTest_function_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->function = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_function_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_function_get" "', argument " "1"" of type '" "SoAlphaTest *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  result = (SoSFEnum *)& ((arg1)->function);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_value_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlphaTest_value_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_value_set" "', argument " "1"" of type '" "SoAlphaTest *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAlphaTest_value_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->value = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_value_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_value_get" "', argument " "1"" of type '" "SoAlphaTest *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  result = (SoSFFloat *)& ((arg1)->value);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlphaTest_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlphaTest *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlphaTest_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlphaTest, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlphaTest_GLRender" "', argument " "1"" of type '" "SoAlphaTest *""'"); 
  }
  arg1 = reinterpret_cast< SoAlphaTest * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoAlphaTest_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAlphaTest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAlphaTest, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAlphaTest_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbLine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbLine *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbLine *)new SbLine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbLine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbLine *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbLine" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbLine" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbLine" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbLine" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbLine *)new SbLine((SbVec3f const &)*arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbLine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbLine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbLine__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbLine__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbLine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbLine::SbLine()\n"
    "    SbLine::SbLine(SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbLine_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLine_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_setValue" "', argument " "1"" of type '" "SbLine *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLine_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbLine_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_setValue" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setValue((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_setPosDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLine_setPosDir", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_setPosDir" "', argument " "1"" of type '" "SbLine *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLine_setPosDir" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_setPosDir" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbLine_setPosDir" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_setPosDir" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->setPosDir((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_getClosestPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLine_getClosestPoints", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_getClosestPoints" "', argument " "1"" of type '" "SbLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLine_getClosestPoints" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_getClosestPoints" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbLine_getClosestPoints" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_getClosestPoints" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbLine_getClosestPoints" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_getClosestPoints" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SbLine const *)arg1)->getClosestPoints((SbLine const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLine_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_getClosestPoint" "', argument " "1"" of type '" "SbLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLine_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLine_getClosestPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = ((SbLine const *)arg1)->getClosestPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_getPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_getPosition" "', argument " "1"" of type '" "SbLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  result = (SbVec3f *) &((SbLine const *)arg1)->getPosition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_getDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_getDirection" "', argument " "1"" of type '" "SbLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  result = (SbVec3f *) &((SbLine const *)arg1)->getDirection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLine_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLine_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLine_output" "', argument " "1"" of type '" "SbLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbLine const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbLine" "', argument " "1"" of type '" "SbLine *""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbLine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbLine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_project" "', argument " "1"" of type '" "SbProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_setViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  SbViewVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbProjector_setViewVolume", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_setViewVolume" "', argument " "1"" of type '" "SbProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewVolume,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbProjector_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbProjector_setViewVolume" "', argument " "2"" of type '" "SbViewVolume const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewVolume * >(argp2);
  (arg1)->setViewVolume((SbViewVolume const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_getViewVolume(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewVolume *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_getViewVolume" "', argument " "1"" of type '" "SbProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  result = (SbViewVolume *) &((SbProjector const *)arg1)->getViewVolume();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewVolume, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_setWorkingSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbProjector_setWorkingSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_setWorkingSpace" "', argument " "1"" of type '" "SbProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setWorkingSpace((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_getWorkingSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_getWorkingSpace" "', argument " "1"" of type '" "SbProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  result = (SbMatrix *) &((SbProjector const *)arg1)->getWorkingSpace();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_copy" "', argument " "1"" of type '" "SbProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  result = (SbProjector *)((SbProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbProjector_tryProject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  float arg3 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbProjector_tryProject", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbProjector_tryProject" "', argument " "1"" of type '" "SbProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbProjector_tryProject" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)(arg1)->tryProject((SbVec2f const &)*arg2,arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbCylinder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbCylinder *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbCylinder *)new SbCylinder();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbLine *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbCylinder *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinder" "', argument " "1"" of type '" "SbLine const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinder" "', argument " "1"" of type '" "SbLine const &""'"); 
  }
  arg1 = reinterpret_cast< SbLine * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinder" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbCylinder *)new SbCylinder((SbLine const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbCylinder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbCylinder__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinder__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbCylinder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbCylinder::SbCylinder()\n"
    "    SbCylinder::SbCylinder(SbLine const &,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbCylinder_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinder_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_setValue" "', argument " "1"" of type '" "SbCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinder_setValue" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_setValue" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbCylinder_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue((SbLine const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_setAxis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinder_setAxis", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_setAxis" "', argument " "1"" of type '" "SbCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinder_setAxis" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_setAxis" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  (arg1)->setAxis((SbLine const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_setRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinder_setRadius", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_setRadius" "', argument " "1"" of type '" "SbCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbCylinder_setRadius" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setRadius(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_getAxis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbLine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_getAxis" "', argument " "1"" of type '" "SbCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  result = (SbLine *) &((SbCylinder const *)arg1)->getAxis();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_getRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_getRadius" "', argument " "1"" of type '" "SbCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  result = (float)((SbCylinder const *)arg1)->getRadius();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_intersect" "', argument " "1"" of type '" "SbCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinder_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinder_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbBool)((SbCylinder const *)arg1)->intersect((SbLine const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_intersect" "', argument " "1"" of type '" "SbCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinder_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinder_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbCylinder_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinder_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SbCylinder const *)arg1)->intersect((SbLine const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinder_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbCylinder_intersect", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbCylinder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbCylinder_intersect__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbCylinder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbCylinder_intersect__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbCylinder_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbCylinder::intersect(SbLine const &,SbVec3f &) const\n"
    "    SbCylinder::intersect(SbLine const &,SbVec3f &,SbVec3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbCylinder_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinder_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinder_output" "', argument " "1"" of type '" "SbCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbCylinder const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCylinder" "', argument " "1"" of type '" "SbCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCylinder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbCylinder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbCylinderProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_project" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_projectAndGetRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_projectAndGetRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_projectAndGetRotation" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_projectAndGetRotation" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_projectAndGetRotation" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinderProjector_projectAndGetRotation" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_projectAndGetRotation" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  result = (arg1)->projectAndGetRotation((SbVec2f const &)*arg2,*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_getRotation" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinderProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_setCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbCylinder *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_setCylinder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_setCylinder" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_setCylinder" "', argument " "2"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_setCylinder" "', argument " "2"" of type '" "SbCylinder const &""'"); 
  }
  arg2 = reinterpret_cast< SbCylinder * >(argp2);
  (arg1)->setCylinder((SbCylinder const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_getCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbCylinder *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_getCylinder" "', argument " "1"" of type '" "SbCylinderProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  result = (SbCylinder *) &((SbCylinderProjector const *)arg1)->getCylinder();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinder, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_setOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_setOrientToEye", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_setOrientToEye" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbCylinderProjector_setOrientToEye" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setOrientToEye(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_isOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_isOrientToEye" "', argument " "1"" of type '" "SbCylinderProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  result = (SbBool)((SbCylinderProjector const *)arg1)->isOrientToEye();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_setFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_setFront", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_setFront" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbCylinderProjector_setFront" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setFront(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_isFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_isFront" "', argument " "1"" of type '" "SbCylinderProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  result = (SbBool)((SbCylinderProjector const *)arg1)->isFront();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_isPointInFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_isPointInFront", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_isPointInFront" "', argument " "1"" of type '" "SbCylinderProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_isPointInFront" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_isPointInFront" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbCylinderProjector const *)arg1)->isPointInFront((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderProjector_setWorkingSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderProjector_setWorkingSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderProjector_setWorkingSpace" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setWorkingSpace((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCylinderProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCylinderProjector" "', argument " "1"" of type '" "SbCylinderProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCylinderProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCylinderProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  SbBool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderSectionProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  float arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderSectionProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbCylinderSectionProjector" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector((SbCylinder const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderSectionProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector((SbCylinder const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbCylinderSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  result = (SbCylinderSectionProjector *)new SbCylinderSectionProjector((SbCylinder const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSectionProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbCylinderSectionProjector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbCylinderSectionProjector__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbCylinderSectionProjector__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbCylinderSectionProjector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinderSectionProjector__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinderSectionProjector__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbCylinderSectionProjector__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbCylinderSectionProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector(float const,SbBool const)\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector(float const)\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector()\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector(SbCylinder const &,float const,SbBool const)\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector(SbCylinder const &,float const)\n"
    "    SbCylinderSectionProjector::SbCylinderSectionProjector(SbCylinder const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_copy" "', argument " "1"" of type '" "SbCylinderSectionProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  result = (SbProjector *)((SbCylinderSectionProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSectionProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_project" "', argument " "1"" of type '" "SbCylinderSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderSectionProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSectionProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSectionProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_getRotation" "', argument " "1"" of type '" "SbCylinderSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderSectionProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSectionProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinderSectionProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSectionProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_setTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSectionProjector_setTolerance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_setTolerance" "', argument " "1"" of type '" "SbCylinderSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbCylinderSectionProjector_setTolerance" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setTolerance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_getTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_getTolerance" "', argument " "1"" of type '" "SbCylinderSectionProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  result = (float)((SbCylinderSectionProjector const *)arg1)->getTolerance();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSectionProjector_isWithinTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSectionProjector_isWithinTolerance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSectionProjector_isWithinTolerance" "', argument " "1"" of type '" "SbCylinderSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderSectionProjector_isWithinTolerance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSectionProjector_isWithinTolerance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)(arg1)->isWithinTolerance((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCylinderSectionProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSectionProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCylinderSectionProjector" "', argument " "1"" of type '" "SbCylinderSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSectionProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCylinderSectionProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCylinderSectionProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbCylinderSectionProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  SbBool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderPlaneProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  float arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderPlaneProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbCylinderPlaneProjector" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector((SbCylinder const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderPlaneProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector((SbCylinder const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbCylinderPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  result = (SbCylinderPlaneProjector *)new SbCylinderPlaneProjector((SbCylinder const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderPlaneProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbCylinderPlaneProjector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbCylinderPlaneProjector__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbCylinderPlaneProjector__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbCylinderPlaneProjector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinderPlaneProjector__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinderPlaneProjector__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbCylinderPlaneProjector__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbCylinderPlaneProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector(float const,SbBool const)\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector(float const)\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector()\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector(SbCylinder const &,float const,SbBool const)\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector(SbCylinder const &,float const)\n"
    "    SbCylinderPlaneProjector::SbCylinderPlaneProjector(SbCylinder const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbCylinderPlaneProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderPlaneProjector_copy" "', argument " "1"" of type '" "SbCylinderPlaneProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderPlaneProjector * >(argp1);
  result = (SbProjector *)((SbCylinderPlaneProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderPlaneProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderPlaneProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderPlaneProjector_project" "', argument " "1"" of type '" "SbCylinderPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderPlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderPlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderPlaneProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderPlaneProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderPlaneProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderPlaneProjector_getRotation" "', argument " "1"" of type '" "SbCylinderPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderPlaneProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderPlaneProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinderPlaneProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderPlaneProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCylinderPlaneProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCylinderPlaneProjector" "', argument " "1"" of type '" "SbCylinderPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderPlaneProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCylinderPlaneProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCylinderPlaneProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbCylinderPlaneProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbCylinderSheetProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbCylinderSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SbCylinderSheetProjector *)new SbCylinderSheetProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSheetProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbCylinderSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbCylinderSheetProjector *)new SbCylinderSheetProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSheetProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbCylinderSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbCylinderSheetProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbCylinderSheetProjector *)new SbCylinderSheetProjector((SbCylinder const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSheetProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbCylinderSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbCylinder,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbCylinder const &""'"); 
  }
  arg1 = reinterpret_cast< SbCylinder * >(argp1);
  result = (SbCylinderSheetProjector *)new SbCylinderSheetProjector((SbCylinder const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCylinderSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbCylinderSheetProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbCylinderSheetProjector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbCylinderSheetProjector__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbCylinderSheetProjector__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbCylinderSheetProjector__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbCylinder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbCylinderSheetProjector__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbCylinderSheetProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbCylinderSheetProjector::SbCylinderSheetProjector(SbBool const)\n"
    "    SbCylinderSheetProjector::SbCylinderSheetProjector()\n"
    "    SbCylinderSheetProjector::SbCylinderSheetProjector(SbCylinder const &,SbBool const)\n"
    "    SbCylinderSheetProjector::SbCylinderSheetProjector(SbCylinder const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbCylinderSheetProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSheetProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSheetProjector_copy" "', argument " "1"" of type '" "SbCylinderSheetProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSheetProjector * >(argp1);
  result = (SbProjector *)((SbCylinderSheetProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSheetProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSheetProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSheetProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSheetProjector_project" "', argument " "1"" of type '" "SbCylinderSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSheetProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderSheetProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSheetProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCylinderSheetProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSheetProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCylinderSheetProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCylinderSheetProjector_getRotation" "', argument " "1"" of type '" "SbCylinderSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSheetProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCylinderSheetProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSheetProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCylinderSheetProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCylinderSheetProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCylinderSheetProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCylinderSheetProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCylinderSheetProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCylinderSheetProjector" "', argument " "1"" of type '" "SbCylinderSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbCylinderSheetProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCylinderSheetProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCylinderSheetProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbCylinderSheetProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbLineProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbLineProjector", 0, 0, 0)) SWIG_fail;
  result = (SbLineProjector *)new SbLineProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLineProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_copy" "', argument " "1"" of type '" "SbLineProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  result = (SbProjector *)((SbLineProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLineProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_project" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_tryProject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  float arg3 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLineProjector_tryProject", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_tryProject" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbLineProjector_tryProject" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbLineProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)(arg1)->tryProject((SbVec2f const &)*arg2,arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_setLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbLineProjector_setLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_setLine" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_setLine" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_setLine" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  (arg1)->setLine((SbLine const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_getLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbLine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_getLine" "', argument " "1"" of type '" "SbLineProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  result = (SbLine *) &((SbLineProjector const *)arg1)->getLine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbLine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_getVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_getVector" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbLineProjector_getVector" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_getVector" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (arg1)->getVector((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_getVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_getVector" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->getVector((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_getVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbLineProjector_getVector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbLineProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbLineProjector_getVector__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbLineProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbLineProjector_getVector__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbLineProjector_getVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbLineProjector::getVector(SbVec2f const &,SbVec2f const &)\n"
    "    SbLineProjector::getVector(SbVec2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_setStartPosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_setStartPosition" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setStartPosition((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_setStartPosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbLineProjector_setStartPosition" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbLineProjector_setStartPosition" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbLineProjector_setStartPosition" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setStartPosition((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbLineProjector_setStartPosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbLineProjector_setStartPosition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbLineProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbLineProjector_setStartPosition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbLineProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbLineProjector_setStartPosition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbLineProjector_setStartPosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbLineProjector::setStartPosition(SbVec2f const &)\n"
    "    SbLineProjector::setStartPosition(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbLineProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbLineProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbLineProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbLineProjector" "', argument " "1"" of type '" "SbLineProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbLineProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbLineProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbLineProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbLineProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbPlaneProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbPlaneProjector" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SbPlaneProjector *)new SbPlaneProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlaneProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbPlaneProjector *)new SbPlaneProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlaneProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPlaneProjector" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlaneProjector" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbPlaneProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbPlaneProjector *)new SbPlaneProjector((SbPlane const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlaneProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbPlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbPlaneProjector" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbPlaneProjector" "', argument " "1"" of type '" "SbPlane const &""'"); 
  }
  arg1 = reinterpret_cast< SbPlane * >(argp1);
  result = (SbPlaneProjector *)new SbPlaneProjector((SbPlane const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbPlaneProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbPlaneProjector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbPlaneProjector__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbPlaneProjector__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbPlaneProjector__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbPlane, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbPlaneProjector__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbPlaneProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPlaneProjector::SbPlaneProjector(SbBool const)\n"
    "    SbPlaneProjector::SbPlaneProjector()\n"
    "    SbPlaneProjector::SbPlaneProjector(SbPlane const &,SbBool const)\n"
    "    SbPlaneProjector::SbPlaneProjector(SbPlane const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_copy" "', argument " "1"" of type '" "SbPlaneProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  result = (SbProjector *)((SbPlaneProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlaneProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_project" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_tryProject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  float arg3 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlaneProjector_tryProject", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_tryProject" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_tryProject" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbPlaneProjector_tryProject" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbPlaneProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_tryProject" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)(arg1)->tryProject((SbVec2f const &)*arg2,arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_setPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlaneProjector_setPlane", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_setPlane" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_setPlane" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_setPlane" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  (arg1)->setPlane((SbPlane const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_getPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbPlane *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_getPlane" "', argument " "1"" of type '" "SbPlaneProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  result = (SbPlane *) &((SbPlaneProjector const *)arg1)->getPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbPlane, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_setOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbPlaneProjector_setOrientToEye", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_setOrientToEye" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbPlaneProjector_setOrientToEye" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setOrientToEye(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_isOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_isOrientToEye" "', argument " "1"" of type '" "SbPlaneProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  result = (SbBool)((SbPlaneProjector const *)arg1)->isOrientToEye();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_getVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_getVector" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbPlaneProjector_getVector" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_getVector" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (arg1)->getVector((SbVec2f const &)*arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_getVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_getVector" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_getVector" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->getVector((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_getVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbPlaneProjector_getVector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlaneProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbPlaneProjector_getVector__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlaneProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbPlaneProjector_getVector__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbPlaneProjector_getVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPlaneProjector::getVector(SbVec2f const &,SbVec2f const &)\n"
    "    SbPlaneProjector::getVector(SbVec2f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_setStartPosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_setStartPosition" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_setStartPosition" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setStartPosition((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_setStartPosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbPlaneProjector_setStartPosition" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbPlaneProjector_setStartPosition" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbPlaneProjector_setStartPosition" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setStartPosition((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbPlaneProjector_setStartPosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbPlaneProjector_setStartPosition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlaneProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbPlaneProjector_setStartPosition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbPlaneProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbPlaneProjector_setStartPosition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbPlaneProjector_setStartPosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbPlaneProjector::setStartPosition(SbVec2f const &)\n"
    "    SbPlaneProjector::setStartPosition(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbPlaneProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbPlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbPlaneProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbPlaneProjector" "', argument " "1"" of type '" "SbPlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbPlaneProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbPlaneProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbPlaneProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbPlaneProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbSphere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbSphere *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbSphere *)new SbSphere();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphere, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3f *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbSphere *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphere" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphere" "', argument " "1"" of type '" "SbVec3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3f * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSphere" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbSphere *)new SbSphere((SbVec3f const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphere, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbSphere", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbSphere__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSphere__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbSphere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSphere::SbSphere()\n"
    "    SbSphere::SbSphere(SbVec3f const &,float const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSphere_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_setValue" "', argument " "1"" of type '" "SbSphere *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_setValue" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbSphere_setValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setValue((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_setCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_setCenter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_setCenter" "', argument " "1"" of type '" "SbSphere *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_setCenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_setCenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setCenter((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_setRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_setRadius", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_setRadius" "', argument " "1"" of type '" "SbSphere *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbSphere_setRadius" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setRadius(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_getCenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_getCenter" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  result = (SbVec3f *) &((SbSphere const *)arg1)->getCenter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_getRadius(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_getRadius" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  result = (float)((SbSphere const *)arg1)->getRadius();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_circumscribe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_circumscribe", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_circumscribe" "', argument " "1"" of type '" "SbSphere *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_circumscribe" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_circumscribe" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  (arg1)->circumscribe((SbBox3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_intersect" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphere_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SbBool)((SbSphere const *)arg1)->intersect((SbLine const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbLine *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_intersect" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_intersect" "', argument " "2"" of type '" "SbLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphere_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_intersect" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbSphere_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_intersect" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  result = (SbBool)((SbSphere const *)arg1)->intersect((SbLine const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbSphere_intersect", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbSphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbSphere_intersect__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbSphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbSphere_intersect__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbSphere_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSphere::intersect(SbLine const &,SbVec3f &) const\n"
    "    SbSphere::intersect(SbLine const &,SbVec3f &,SbVec3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSphere_pointInside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_pointInside", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_pointInside" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphere_pointInside" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphere_pointInside" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbSphere const *)arg1)->pointInside((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphere_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphere_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphere_output" "', argument " "1"" of type '" "SbSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbSphere const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphere, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbSphere" "', argument " "1"" of type '" "SbSphere *""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbSphere_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbSphere, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbSphere_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbSphereProjector_projectAndGetRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  SbRotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_projectAndGetRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_projectAndGetRotation" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereProjector_projectAndGetRotation" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_projectAndGetRotation" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbRotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphereProjector_projectAndGetRotation" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_projectAndGetRotation" "', argument " "3"" of type '" "SbRotation &""'"); 
  }
  arg3 = reinterpret_cast< SbRotation * >(argp3);
  result = (arg1)->projectAndGetRotation((SbVec2f const &)*arg2,*arg3);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_getRotation" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphereProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_setSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_setSphere", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_setSphere" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereProjector_setSphere" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_setSphere" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  (arg1)->setSphere((SbSphere const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_getSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbSphere *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_getSphere" "', argument " "1"" of type '" "SbSphereProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  result = (SbSphere *) &((SbSphereProjector const *)arg1)->getSphere();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphere, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_setOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_setOrientToEye", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_setOrientToEye" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbSphereProjector_setOrientToEye" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setOrientToEye(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_isOrientToEye(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_isOrientToEye" "', argument " "1"" of type '" "SbSphereProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  result = (SbBool)((SbSphereProjector const *)arg1)->isOrientToEye();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_setFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_setFront", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_setFront" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbSphereProjector_setFront" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setFront(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_isFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_isFront" "', argument " "1"" of type '" "SbSphereProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  result = (SbBool)((SbSphereProjector const *)arg1)->isFront();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_isPointInFront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_isPointInFront", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_isPointInFront" "', argument " "1"" of type '" "SbSphereProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereProjector_isPointInFront" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_isPointInFront" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)((SbSphereProjector const *)arg1)->isPointInFront((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereProjector_setWorkingSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereProjector_setWorkingSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereProjector_setWorkingSpace" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereProjector_setWorkingSpace" "', argument " "2"" of type '" "SbMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbMatrix * >(argp2);
  (arg1)->setWorkingSpace((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbSphereProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbSphereProjector" "', argument " "1"" of type '" "SbSphereProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbSphereProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbSphereProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SbSphereSheetProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SbSphereSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbSphereSheetProjector" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (SbSphereSheetProjector *)new SbSphereSheetProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSheetProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbSphereSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbSphereSheetProjector *)new SbSphereSheetProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSheetProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbSphereSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphereSheetProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphereSheetProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSphereSheetProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbSphereSheetProjector *)new SbSphereSheetProjector((SbSphere const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSheetProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbSphereSheetProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphereSheetProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphereSheetProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  result = (SbSphereSheetProjector *)new SbSphereSheetProjector((SbSphere const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSheetProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSheetProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbSphereSheetProjector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbSphereSheetProjector__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbSphereSheetProjector__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbSphereSheetProjector__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSphereSheetProjector__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbSphereSheetProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSphereSheetProjector::SbSphereSheetProjector(SbBool const)\n"
    "    SbSphereSheetProjector::SbSphereSheetProjector()\n"
    "    SbSphereSheetProjector::SbSphereSheetProjector(SbSphere const &,SbBool const)\n"
    "    SbSphereSheetProjector::SbSphereSheetProjector(SbSphere const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSphereSheetProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSheetProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSheetProjector_copy" "', argument " "1"" of type '" "SbSphereSheetProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSheetProjector * >(argp1);
  result = (SbProjector *)((SbSphereSheetProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSheetProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSheetProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSheetProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSheetProjector_project" "', argument " "1"" of type '" "SbSphereSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSheetProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereSheetProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSheetProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSheetProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSheetProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSheetProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSheetProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSheetProjector_getRotation" "', argument " "1"" of type '" "SbSphereSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSheetProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereSheetProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSheetProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphereSheetProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSheetProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbSphereSheetProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSheetProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSheetProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbSphereSheetProjector" "', argument " "1"" of type '" "SbSphereSheetProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSheetProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbSphereSheetProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbSphereSheetProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbSphereSheetProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  SbBool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSphereSectionProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  float arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSphereSectionProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbSphereSectionProjector" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector((SbSphere const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSphereSectionProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector((SbSphere const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbSphereSectionProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  result = (SbSphereSectionProjector *)new SbSphereSectionProjector((SbSphere const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSphereSectionProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbSphereSectionProjector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbSphereSectionProjector__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbSphereSectionProjector__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbSphereSectionProjector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSphereSectionProjector__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSphereSectionProjector__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbSphereSectionProjector__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbSphereSectionProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector(float const,SbBool const)\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector(float const)\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector()\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector(SbSphere const &,float const,SbBool const)\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector(SbSphere const &,float const)\n"
    "    SbSphereSectionProjector::SbSphereSectionProjector(SbSphere const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_copy" "', argument " "1"" of type '" "SbSphereSectionProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  result = (SbProjector *)((SbSphereSectionProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSectionProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_project" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereSectionProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSectionProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSectionProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_getRotation" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereSectionProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSectionProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSphereSectionProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSectionProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_setTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSectionProjector_setTolerance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_setTolerance" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbSphereSectionProjector_setTolerance" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setTolerance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_getTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_getTolerance" "', argument " "1"" of type '" "SbSphereSectionProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  result = (float)((SbSphereSectionProjector const *)arg1)->getTolerance();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_setRadialFactor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_setRadialFactor" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbSphereSectionProjector_setRadialFactor" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setRadialFactor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_setRadialFactor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_setRadialFactor" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  (arg1)->setRadialFactor();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_setRadialFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbSphereSectionProjector_setRadialFactor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbSphereSectionProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbSphereSectionProjector_setRadialFactor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbSphereSectionProjector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbSphereSectionProjector_setRadialFactor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbSphereSectionProjector_setRadialFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSphereSectionProjector::setRadialFactor(float const)\n"
    "    SbSphereSectionProjector::setRadialFactor()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_getRadialFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_getRadialFactor" "', argument " "1"" of type '" "SbSphereSectionProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  result = (float)((SbSphereSectionProjector const *)arg1)->getRadialFactor();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSphereSectionProjector_isWithinTolerance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSphereSectionProjector_isWithinTolerance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSphereSectionProjector_isWithinTolerance" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSphereSectionProjector_isWithinTolerance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSphereSectionProjector_isWithinTolerance" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  result = (SbBool)(arg1)->isWithinTolerance((SbVec3f const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbSphereSectionProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSphereSectionProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSphereSectionProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbSphereSectionProjector" "', argument " "1"" of type '" "SbSphereSectionProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSphereSectionProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbSphereSectionProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbSphereSectionProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbSphereSectionProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  SbBool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSpherePlaneProjector" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  float arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSpherePlaneProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbSpherePlaneProjector" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector((SbSphere const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbSpherePlaneProjector" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector((SbSphere const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbSpherePlaneProjector *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSphere const &""'"); 
  }
  arg1 = reinterpret_cast< SbSphere * >(argp1);
  result = (SbSpherePlaneProjector *)new SbSpherePlaneProjector((SbSphere const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbSpherePlaneProjector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbSpherePlaneProjector", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbSpherePlaneProjector__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbSpherePlaneProjector__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbSpherePlaneProjector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSpherePlaneProjector__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbSpherePlaneProjector__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbSpherePlaneProjector__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbSpherePlaneProjector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector(float const,SbBool const)\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector(float const)\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector()\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector(SbSphere const &,float const,SbBool const)\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector(SbSphere const &,float const)\n"
    "    SbSpherePlaneProjector::SbSpherePlaneProjector(SbSphere const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbSpherePlaneProjector_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSpherePlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbProjector *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSpherePlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSpherePlaneProjector_copy" "', argument " "1"" of type '" "SbSpherePlaneProjector const *""'"); 
  }
  arg1 = reinterpret_cast< SbSpherePlaneProjector * >(argp1);
  result = (SbProjector *)((SbSpherePlaneProjector const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbProjector, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSpherePlaneProjector_project(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSpherePlaneProjector *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3f result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSpherePlaneProjector_project", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSpherePlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSpherePlaneProjector_project" "', argument " "1"" of type '" "SbSpherePlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSpherePlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSpherePlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSpherePlaneProjector_project" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  result = (arg1)->project((SbVec2f const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbSpherePlaneProjector_getRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSpherePlaneProjector *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbSpherePlaneProjector_getRotation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSpherePlaneProjector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbSpherePlaneProjector_getRotation" "', argument " "1"" of type '" "SbSpherePlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSpherePlaneProjector * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbSpherePlaneProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSpherePlaneProjector_getRotation" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbSpherePlaneProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbSpherePlaneProjector_getRotation" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (arg1)->getRotation((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj((new SbRotation(result)), SWIGTYPE_p_SbRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbSpherePlaneProjector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbSpherePlaneProjector *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbSpherePlaneProjector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbSpherePlaneProjector" "', argument " "1"" of type '" "SbSpherePlaneProjector *""'"); 
  }
  arg1 = reinterpret_cast< SbSpherePlaneProjector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbSpherePlaneProjector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbSpherePlaneProjector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbSpherePlaneProjector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbClip__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClipCallback *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  SbClip *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_SbClip" "', argument " "1"" of type '" "SbClipCallback *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbClip" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (SbClip *)new SbClip(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbClip, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbClip__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClipCallback *arg1 = 0 ;
  SbClip *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_SbClip" "', argument " "1"" of type '" "SbClipCallback *""'"); 
    }
  }
  result = (SbClip *)new SbClip(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbClip, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbClip__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbClip *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbClip *)new SbClip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbClip, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbClip(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbClip", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbClip__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbClip__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbClip__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbClip'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbClip::SbClip(SbClipCallback *,void *)\n"
    "    SbClip::SbClip(SbClipCallback *)\n"
    "    SbClip::SbClip()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbClip_addVertex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_addVertex" "', argument " "1"" of type '" "SbClip *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbClip_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbClip_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbClip_addVertex" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addVertex((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_addVertex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_addVertex" "', argument " "1"" of type '" "SbClip *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbClip_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbClip_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->addVertex((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_addVertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbClip_addVertex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbClip, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbClip_addVertex__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbClip, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbClip_addVertex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbClip_addVertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbClip::addVertex(SbVec3f const &,void *)\n"
    "    SbClip::addVertex(SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbClip_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_reset" "', argument " "1"" of type '" "SbClip *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_clip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  SbPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbClip_clip", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_clip" "', argument " "1"" of type '" "SbClip *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbClip_clip" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbClip_clip" "', argument " "2"" of type '" "SbPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  (arg1)->clip((SbPlane const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_getNumVertices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_getNumVertices" "', argument " "1"" of type '" "SbClip const *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  result = (int)((SbClip const *)arg1)->getNumVertices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_getVertex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_getVertex" "', argument " "1"" of type '" "SbClip const *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbClip_getVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbClip_getVertex" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbClip_getVertex" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbClip_getVertex" "', argument " "4"" of type '" "void **""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);
  ((SbClip const *)arg1)->getVertex(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_getVertex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  int arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_getVertex" "', argument " "1"" of type '" "SbClip const *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbClip_getVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbClip_getVertex" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbClip_getVertex" "', argument " "3"" of type '" "SbVec3f &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  ((SbClip const *)arg1)->getVertex(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbClip_getVertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbClip_getVertex", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbClip, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbClip_getVertex__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbClip, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_p_void, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbClip_getVertex__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbClip_getVertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbClip::getVertex(int const,SbVec3f &,void **) const\n"
    "    SbClip::getVertex(int const,SbVec3f &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbClip_getVertexData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbClip_getVertexData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbClip_getVertexData" "', argument " "1"" of type '" "SbClip const *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbClip_getVertexData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void *)((SbClip const *)arg1)->getVertexData(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbClip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbClip, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbClip" "', argument " "1"" of type '" "SbClip *""'"); 
  }
  arg1 = reinterpret_cast< SbClip * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbClip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbClip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbClip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDPRotation *)new SbDPRotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbDPRotation" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbDPRotation *)new SbDPRotation((SbVec3d const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double *arg1 = (double *)0 ;
  double temp1[4] ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    convert_SbVec4d_array(swig_obj[0], temp1);
    arg1 = temp1;
  }
  result = (SbDPRotation *)new SbDPRotation((double const (*))arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbDPRotation" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbDPRotation" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SbDPRotation" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (SbDPRotation *)new SbDPRotation(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbDPMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< SbDPMatrix * >(argp1);
  result = (SbDPRotation *)new SbDPRotation((SbDPMatrix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPRotation" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbDPRotation" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPRotation" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbDPRotation *)new SbDPRotation((SbVec3d const &)*arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPRotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbDPRotation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbDPRotation__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbDPRotation__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = PySequence_Check(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_SbDPRotation__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbDPRotation__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbDPRotation__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SbDPRotation__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbDPRotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPRotation::SbDPRotation()\n"
    "    SbDPRotation::SbDPRotation(SbVec3d const &,double const)\n"
    "    SbDPRotation::SbDPRotation(double const [4])\n"
    "    SbDPRotation::SbDPRotation(double const,double const,double const,double const)\n"
    "    SbDPRotation::SbDPRotation(SbDPMatrix const &)\n"
    "    SbDPRotation::SbDPRotation(SbVec3d const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_getValue" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  result = (double *)((SbDPRotation const *)arg1)->getValue();
  {
    resultobj = Py_BuildValue("(ffff)",
      (double)(*(result)),
      (double)(*(result+1)),
      (double)(*(result+2)),
      (double)(*(result+3)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_setValue" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPRotation_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbDPRotation_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbDPRotation_setValue" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (SbDPRotation *) &(arg1)->setValue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_getAxisAngle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbVec3d();
  }
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_getAxisAngle" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ((SbDPRotation const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbVec3d, 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbDPMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_getMatrix" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ((SbDPRotation const *)arg1)->getValue(*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbDPMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_invert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_invert" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  result = (SbDPRotation *) &(arg1)->invert();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbDPRotation result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_inverse" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  result = ((SbDPRotation const *)arg1)->inverse();
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  double *arg2 = (double *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2[4] ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_setValue" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  {
    convert_SbVec4d_array(swig_obj[1], temp2);
    arg2 = temp2;
  }
  result = (SbDPRotation *) &(arg1)->setValue((double const (*))arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_setValue" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbDPMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPMatrix * >(argp2);
  result = (SbDPRotation *) &(arg1)->setValue((SbDPMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_setValue" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPRotation_setValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbDPRotation *) &(arg1)->setValue((SbVec3d const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  {
    
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_setValue" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPRotation_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  result = (SbDPRotation *) &(arg1)->setValue((SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPRotation_setValue", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPMatrix, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPRotation_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySequence_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SbDPRotation_setValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPRotation_setValue__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbDPRotation_setValue__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbDPRotation_setValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPRotation_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPRotation::setValue(double const,double const,double const,double const)\n"
    "    SbDPRotation::setValue(double const [4])\n"
    "    SbDPRotation::setValue(SbDPMatrix const &)\n"
    "    SbDPRotation::setValue(SbVec3d const &,double const)\n"
    "    SbDPRotation::setValue(SbVec3d const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_equals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_equals" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_equals" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_equals" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPRotation_equals" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (SbBool)((SbDPRotation const *)arg1)->equals((SbDPRotation const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_multVec(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_multVec", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_multVec" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_multVec" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_multVec" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPRotation_multVec" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_multVec" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  ((SbDPRotation const *)arg1)->multVec((SbVec3d const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_scaleAngle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_scaleAngle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_scaleAngle" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPRotation_scaleAngle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scaleAngle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_slerp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbDPRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_slerp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_slerp" "', argument " "1"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_slerp" "', argument " "1"" of type '" "SbDPRotation const &""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation_slerp" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation_slerp" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbDPRotation_slerp" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = SbDPRotation::slerp((SbDPRotation const &)*arg1,(SbDPRotation const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_identity", 0, 0, 0)) SWIG_fail;
  result = SbDPRotation::identity();
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation_output" "', argument " "1"" of type '" "SbDPRotation const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbDPRotation const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___imul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___imul__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation___imul__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation___imul__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  result = (SbDPRotation *) &(arg1)->operator *=((SbDPRotation const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___imul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbDPRotation *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___imul__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPRotation___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbDPRotation *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPRotation___imul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPRotation___imul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbDPRotation___imul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPRotation___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPRotation::operator *=(SbDPRotation const &)\n"
    "    SbDPRotation::operator *=(double const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___mul__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation___mul__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation___mul__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  result = SbDPRotation___mul____SWIG_0(arg1,(SbDPRotation const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbDPRotation result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___mul__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPRotation___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = SbDPRotation___mul____SWIG_1(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new SbDPRotation(result)), SWIGTYPE_p_SbDPRotation, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___mul____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3d result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___mul__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation___mul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation___mul__" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = SbDPRotation___mul____SWIG_2(arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPRotation___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPRotation, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPRotation___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbDPRotation___mul____SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPRotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbDPRotation___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___eq__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation___eq__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation___eq__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  result = (int)SbDPRotation___eq__(arg1,(SbDPRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPRotation___nq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  SbDPRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPRotation___nq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPRotation___nq__" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPRotation___nq__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPRotation___nq__" "', argument " "2"" of type '" "SbDPRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPRotation * >(argp2);
  result = (int)SbDPRotation___nq__(arg1,(SbDPRotation const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbDPRotation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPRotation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPRotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDPRotation" "', argument " "1"" of type '" "SbDPRotation *""'"); 
  }
  arg1 = reinterpret_cast< SbDPRotation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbDPRotation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDPRotation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDPRotation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbDPLine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbDPLine *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDPLine *)new SbDPLine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPLine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPLine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPLine *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPLine" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPLine" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbDPLine" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPLine" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbDPLine *)new SbDPLine((SbVec3d const &)*arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPLine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPLine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbDPLine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbDPLine__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbDPLine__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbDPLine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPLine::SbDPLine()\n"
    "    SbDPLine::SbDPLine(SbVec3d const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPLine_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPLine_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_setValue" "', argument " "1"" of type '" "SbDPLine *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPLine_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_setValue" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPLine_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_setValue" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->setValue((SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_setPosDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPLine_setPosDir", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_setPosDir" "', argument " "1"" of type '" "SbDPLine *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPLine_setPosDir" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_setPosDir" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPLine_setPosDir" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_setPosDir" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  (arg1)->setPosDir((SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_getClosestPoints(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  SbDPLine *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  SbVec3d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPLine_getClosestPoints", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_getClosestPoints" "', argument " "1"" of type '" "SbDPLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPLine_getClosestPoints" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_getClosestPoints" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPLine_getClosestPoints" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_getClosestPoints" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbDPLine_getClosestPoints" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_getClosestPoints" "', argument " "4"" of type '" "SbVec3d &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3d * >(argp4);
  result = (SbBool)((SbDPLine const *)arg1)->getClosestPoints((SbDPLine const &)*arg2,*arg3,*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_getClosestPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbVec3d result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPLine_getClosestPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_getClosestPoint" "', argument " "1"" of type '" "SbDPLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPLine_getClosestPoint" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPLine_getClosestPoint" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = ((SbDPLine const *)arg1)->getClosestPoint((SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3d(result)), SWIGTYPE_p_SbVec3d, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_getPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_getPosition" "', argument " "1"" of type '" "SbDPLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  result = (SbVec3d *) &((SbDPLine const *)arg1)->getPosition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_getDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_getDirection" "', argument " "1"" of type '" "SbDPLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  result = (SbVec3d *) &((SbDPLine const *)arg1)->getDirection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPLine_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPLine_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPLine_output" "', argument " "1"" of type '" "SbDPLine const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbDPLine const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbDPLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPLine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDPLine" "', argument " "1"" of type '" "SbDPLine *""'"); 
  }
  arg1 = reinterpret_cast< SbDPLine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbDPLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDPLine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDPLine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbDPPlane__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbDPPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbDPPlane *)new SbDPPlane();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPPlane__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SbDPPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbDPPlane" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (SbDPPlane *)new SbDPPlane((SbVec3d const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPPlane__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbDPPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbDPPlane" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SbDPPlane" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "3"" of type '" "SbVec3d const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  result = (SbDPPlane *)new SbDPPlane((SbVec3d const &)*arg1,(SbVec3d const &)*arg2,(SbVec3d const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPPlane__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbVec3d *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbDPPlane *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "1"" of type '" "SbVec3d const &""'"); 
  }
  arg1 = reinterpret_cast< SbVec3d * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbDPPlane" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbDPPlane" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbDPPlane *)new SbDPPlane((SbVec3d const &)*arg1,(SbVec3d const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbDPPlane(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbDPPlane", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbDPPlane__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbDPPlane__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbDPPlane__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SbDPPlane__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbDPPlane'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPPlane::SbDPPlane()\n"
    "    SbDPPlane::SbDPPlane(SbVec3d const &,double const)\n"
    "    SbDPPlane::SbDPPlane(SbVec3d const &,SbVec3d const &,SbVec3d const &)\n"
    "    SbDPPlane::SbDPPlane(SbVec3d const &,SbVec3d const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_offset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane_offset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_offset" "', argument " "1"" of type '" "SbDPPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbDPPlane_offset" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->offset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_intersect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPLine *arg2 = 0 ;
  SbVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_intersect" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPLine,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane_intersect" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_intersect" "', argument " "2"" of type '" "SbDPLine const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPLine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPPlane_intersect" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_intersect" "', argument " "3"" of type '" "SbVec3d &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3d * >(argp3);
  result = (SbBool)((SbDPPlane const *)arg1)->intersect((SbDPLine const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbDPMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_transform" "', argument " "1"" of type '" "SbDPPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  (arg1)->transform((SbDPMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbDPMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_isInHalfSpace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane_isInHalfSpace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_isInHalfSpace" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane_isInHalfSpace" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_isInHalfSpace" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (SbBool)((SbDPPlane const *)arg1)->isInHalfSpace((SbVec3d const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_getDistance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbVec3d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane_getDistance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_getDistance" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3d,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane_getDistance" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_getDistance" "', argument " "2"" of type '" "SbVec3d const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3d * >(argp2);
  result = (double)((SbDPPlane const *)arg1)->getDistance((SbVec3d const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3d *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_getNormal" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  result = (SbVec3d *) &((SbDPPlane const *)arg1)->getNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3d, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_getDistanceFromOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_getDistanceFromOrigin" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  result = (double)((SbDPPlane const *)arg1)->getDistanceFromOrigin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane_output", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_output" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  ((SbDPPlane const *)arg1)->print(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_intersect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPPlane *arg2 = 0 ;
  SbDPLine *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane_intersect" "', argument " "1"" of type '" "SbDPPlane const *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane_intersect" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_intersect" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPPlane * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbDPLine,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbDPPlane_intersect" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane_intersect" "', argument " "3"" of type '" "SbDPLine &""'"); 
  }
  arg3 = reinterpret_cast< SbDPLine * >(argp3);
  result = (SbBool)((SbDPPlane const *)arg1)->intersect((SbDPPlane const &)*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbDPPlane_intersect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbDPPlane_intersect", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPLine, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbVec3d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPPlane_intersect__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbDPPlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbDPPlane, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbDPLine, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbDPPlane_intersect__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbDPPlane_intersect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbDPPlane::intersect(SbDPLine const &,SbVec3d &) const\n"
    "    SbDPPlane::intersect(SbDPPlane const &,SbDPLine &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbDPPlane___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane___eq__" "', argument " "1"" of type '" "SbDPPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane___eq__" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane___eq__" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPPlane * >(argp2);
  result = (int)SbDPPlane___eq__(arg1,(SbDPPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbDPPlane___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  SbDPPlane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbDPPlane___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbDPPlane___ne__" "', argument " "1"" of type '" "SbDPPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbDPPlane,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbDPPlane___ne__" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbDPPlane___ne__" "', argument " "2"" of type '" "SbDPPlane const &""'"); 
  }
  arg2 = reinterpret_cast< SbDPPlane * >(argp2);
  result = (int)SbDPPlane___ne__(arg1,(SbDPPlane const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_SbDPPlane(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbDPPlane *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbDPPlane, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbDPPlane" "', argument " "1"" of type '" "SbDPPlane *""'"); 
  }
  arg1 = reinterpret_cast< SbDPPlane * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbDPPlane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbDPPlane, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbDPPlane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbHeapFuncs_eval_func_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  float (*arg2)(void *) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbHeapFuncs_eval_func_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_eval_func_set" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__float);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeapFuncs_eval_func_set" "', argument " "2"" of type '" "float (*)(void *)""'"); 
    }
  }
  if (arg1) (arg1)->eval_func = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeapFuncs_eval_func_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float (*result)(void *) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_eval_func_get" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  result = (float (*)(void *)) ((arg1)->eval_func);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__float);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeapFuncs_get_index_func_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  int (*arg2)(void *) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbHeapFuncs_get_index_func_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_get_index_func_set" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeapFuncs_get_index_func_set" "', argument " "2"" of type '" "int (*)(void *)""'"); 
    }
  }
  if (arg1) (arg1)->get_index_func = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeapFuncs_get_index_func_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)(void *) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_get_index_func_get" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  result = (int (*)(void *)) ((arg1)->get_index_func);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeapFuncs_set_index_func_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void (*arg2)(void *,int) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbHeapFuncs_set_index_func_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_set_index_func_set" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeapFuncs_set_index_func_set" "', argument " "2"" of type '" "void (*)(void *,int)""'"); 
    }
  }
  if (arg1) (arg1)->set_index_func = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeapFuncs_set_index_func_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void (*result)(void *,int) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeapFuncs_set_index_func_get" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  result = (void (*)(void *,int)) ((arg1)->set_index_func);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_int__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbHeapFuncs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbHeapFuncs", 0, 0, 0)) SWIG_fail;
  result = (SbHeapFuncs *)new SbHeapFuncs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbHeapFuncs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbHeapFuncs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeapFuncs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbHeapFuncs" "', argument " "1"" of type '" "SbHeapFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbHeapFuncs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbHeapFuncs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbHeapFuncs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbHeap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SbHeap *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbHeapFuncs,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbHeap" "', argument " "1"" of type '" "SbHeapFuncs const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbHeap" "', argument " "1"" of type '" "SbHeapFuncs const &""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SbHeap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbHeap *)new SbHeap((SbHeapFuncs const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbHeap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbHeap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeapFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbHeap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbHeapFuncs,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbHeap" "', argument " "1"" of type '" "SbHeapFuncs const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbHeap" "', argument " "1"" of type '" "SbHeapFuncs const &""'"); 
  }
  arg1 = reinterpret_cast< SbHeapFuncs * >(argp1);
  result = (SbHeap *)new SbHeap((SbHeapFuncs const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbHeap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbHeap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbHeap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbHeapFuncs, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbHeap__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbHeapFuncs, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SbHeap__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbHeap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbHeap::SbHeap(SbHeapFuncs const &,int const)\n"
    "    SbHeap::SbHeap(SbHeapFuncs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbHeap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbHeap" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_emptyHeap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_emptyHeap" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  (arg1)->emptyHeap();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_size" "', argument " "1"" of type '" "SbHeap const *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  result = (int)((SbHeap const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbHeap_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_add" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbHeap_add" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (int)(arg1)->add(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_remove__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_remove" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbHeap_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_remove__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_remove" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbHeap_remove" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbHeap_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbHeap_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbHeap_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbHeap_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbHeap::remove(int const)\n"
    "    SbHeap::remove(void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbHeap_extractMin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_extractMin" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  result = (void *)(arg1)->extractMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_getMin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_getMin" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  result = (void *)(arg1)->getMin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_newWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_newWeight" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbHeap_newWeight" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbHeap_newWeight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->newWeight(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_newWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_newWeight" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbHeap_newWeight" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->newWeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_newWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbHeap_newWeight", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbHeap_newWeight__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SbHeap_newWeight__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbHeap_newWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbHeap::newWeight(void *,int)\n"
    "    SbHeap::newWeight(void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbHeap_buildHeap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  SbBool (*arg2)(float,void *) = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_buildHeap" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_float_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeap_buildHeap" "', argument " "2"" of type '" "SbBool (*)(float,void *)""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  result = (SbBool)(arg1)->buildHeap(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_buildHeap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  SbBool (*arg2)(float,void *) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_buildHeap" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_float_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeap_buildHeap" "', argument " "2"" of type '" "SbBool (*)(float,void *)""'"); 
    }
  }
  result = (SbBool)(arg1)->buildHeap(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_buildHeap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_buildHeap" "', argument " "1"" of type '" "SbHeap *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  result = (SbBool)(arg1)->buildHeap();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbHeap_buildHeap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbHeap_buildHeap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbHeap_buildHeap__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_float_p_void__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbHeap_buildHeap__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbHeap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_float_p_void__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SbHeap_buildHeap__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbHeap_buildHeap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbHeap::buildHeap(SbBool (*)(float,void *),void *)\n"
    "    SbHeap::buildHeap(SbBool (*)(float,void *))\n"
    "    SbHeap::buildHeap()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbHeap_traverseHeap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbHeap *arg1 = 0 ;
  SbBool (*arg2)(void *,void *) = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbHeap_traverseHeap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbHeap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbHeap_traverseHeap" "', argument " "1"" of type '" "SbHeap const *""'"); 
  }
  arg1 = reinterpret_cast< SbHeap * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbHeap_traverseHeap" "', argument " "2"" of type '" "SbBool (*)(void *,void *)""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbHeap_traverseHeap" "', argument " "3"" of type '" "void *""'"); 
  }
  result = (SbBool)((SbHeap const *)arg1)->traverseHeap(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbHeap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbHeap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbHeap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbImage *)new SbImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  SbImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    unsigned char * image;
    PyObject * buf = swig_obj[0];
    PyObject * vec2s = swig_obj[0];
    PyObject * nc = swig_obj[0];
    
    if ((SWIG_ConvertPtr(vec2s, (void **) &arg2, SWIGTYPE_p_SbVec2s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    
    
    
    if (PyBytes_Check(buf))
    
    {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg1 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  result = (SbImage *)new SbImage((unsigned char const *)arg1,(SbVec2s const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbImage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int arg3 ;
  SbImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    unsigned char * image;
    PyObject * buf = swig_obj[0];
    PyObject * vec3s = swig_obj[0];
    PyObject * nc = swig_obj[0];
    
    if ((SWIG_ConvertPtr(vec3s, (void **)&arg2, SWIGTYPE_p_SbVec3s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    if (PyString_Check(buf)) {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * (*arg2)[2] * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg1 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  result = (SbImage *)new SbImage((unsigned char const *)arg1,(SbVec3s const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbImage__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbImage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbImage,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbImage" "', argument " "1"" of type '" "SbImage const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbImage" "', argument " "1"" of type '" "SbImage const &""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  result = (SbImage *)new SbImage((SbImage const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbImage", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbImage__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_SbImage__SWIG_1(self, argc, argv);
      }
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_SbImage__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbImage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_SbImage__SWIG_2(self, argc, argv);
      }
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_SbImage__SWIG_2(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbImage__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbImage, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbImage__SWIG_3(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbImage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::SbImage()\n"
    "    SbImage::SbImage(unsigned char const *,SbVec2s const &,int const)\n"
    "    SbImage::SbImage(unsigned char const *,SbVec3s const &,int const)\n"
    "    SbImage::SbImage(SbImage const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbImage" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_setValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_setValue" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    unsigned char * image;
    PyObject * vec2s = swig_obj[1];
    PyObject * nc = swig_obj[1];
    PyObject * buf = swig_obj[1];
    
    if ((SWIG_ConvertPtr(vec2s, (void **)&arg2, SWIGTYPE_p_SbVec2s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    
    
    
    if (PyBytes_Check(buf))
    
    {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg4 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  (arg1)->setValue((SbVec2s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_setValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_setValue" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    unsigned char * image;
    PyObject * vec3s = swig_obj[1];
    PyObject * nc = swig_obj[1];
    PyObject * buf = swig_obj[1];
    
    if ((SWIG_ConvertPtr(vec3s, (void **)&arg2, SWIGTYPE_p_SbVec3s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    
    
    
    if (PyBytes_Check(buf))
    
    {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * ((*arg2)[2] ? (*arg2)[2] : 1) * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg4 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  (arg1)->setValue((SbVec3s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbImage_setValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_SbImage_setValue__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_SbImage_setValue__SWIG_0(self, argc, argv);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbImage_setValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_SbImage_setValue__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_SbImage_setValue__SWIG_1(self, argc, argv);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbImage_setValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbImage_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::setValue(SbVec2s const &,int const,unsigned char const *)\n"
    "    SbImage::setValue(SbVec3s const &,int const,unsigned char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbImage_setValuePtr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_setValuePtr" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    unsigned char * image;
    PyObject * vec2s = swig_obj[1];
    PyObject * nc = swig_obj[1];
    PyObject * buf = swig_obj[1];
    
    if ((SWIG_ConvertPtr(vec2s, (void **)&arg2, SWIGTYPE_p_SbVec2s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    
    
    
    if (PyBytes_Check(buf))
    
    {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg4 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  (arg1)->setValuePtr((SbVec2s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_setValuePtr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int arg3 ;
  unsigned char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_setValuePtr" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    unsigned char * image;
    PyObject * vec3s = swig_obj[1];
    PyObject * nc = swig_obj[1];
    PyObject * buf = swig_obj[1];
    
    if ((SWIG_ConvertPtr(vec3s, (void **)&arg2, SWIGTYPE_p_SbVec3s, SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
      PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
    }
    arg3 = PyInt_AsLong(nc);
    
    
    
    if (PyBytes_Check(buf))
    
    {
      Py_ssize_t len = (*arg2)[0] * (*arg2)[1] * ((*arg2)[2] ? (*arg2)[2] : 1) * arg3;
      
      
      
      PyBytes_AsStringAndSize(buf, (char **)&image, &len);
      
      arg4 = image;
    } else {
      PyErr_SetString(PyExc_TypeError, "expected a string."); SWIG_fail;
    }
  }
  (arg1)->setValuePtr((SbVec3s const &)*arg2,arg3,(unsigned char const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_setValuePtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbImage_setValuePtr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_SbImage_setValuePtr__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_SbImage_setValuePtr__SWIG_0(self, argc, argv);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbImage_setValuePtr__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_SbImage_setValuePtr__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_SbImage_setValuePtr__SWIG_1(self, argc, argv);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbImage_setValuePtr__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbImage_setValuePtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::setValuePtr(SbVec2s const &,int const,unsigned char const *)\n"
    "    SbImage::setValuePtr(SbVec3s const &,int const,unsigned char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbImage_getValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_getValue" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage_getValue" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage_getValue" "', argument " "2"" of type '" "SbVec2s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_getValue" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage_getValue" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)((SbImage const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_getValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbVec3s *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_getValue" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage_getValue" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage_getValue" "', argument " "2"" of type '" "SbVec3s &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3s * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_getValue" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage_getValue" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (unsigned char *)((SbImage const *)arg1)->getValue(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_getSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_getSize" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  result = ((SbImage const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec3s(result)), SWIGTYPE_p_SbVec3s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbString **arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_readFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_readFile" "', argument " "3"" of type '" "SbString const *const *""'"); 
  }
  arg3 = reinterpret_cast< SbString ** >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbImage_readFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (SbBool)(arg1)->readFile((SbString const &)*arg2,(SbString const *const *)arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbString **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_readFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_readFile" "', argument " "3"" of type '" "SbString const *const *""'"); 
  }
  arg3 = reinterpret_cast< SbString ** >(argp3);
  result = (SbBool)(arg1)->readFile((SbString const &)*arg2,(SbString const *const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_readFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)(arg1)->readFile((SbString const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbImage_readFile", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SbImage_readFile__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_SbString, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbImage_readFile__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_SbString, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbImage_readFile__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbImage_readFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::readFile(SbString const &,SbString const *const *,int const)\n"
    "    SbImage::readFile(SbString const &,SbString const *const *)\n"
    "    SbImage::readFile(SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbImage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbImage___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage___eq__" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbImage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage___eq__" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage___eq__" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  result = (int)((SbImage const *)arg1)->operator ==((SbImage const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbImage___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbImage___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage___ne__" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbImage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage___ne__" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbImage___ne__" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  result = (int)((SbImage const *)arg1)->operator !=((SbImage const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SbImage_addReadImageCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImageReadImageCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbImage_addReadImageCB", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbImage_addReadImageCB" "', argument " "1"" of type '" "SbImageReadImageCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage_addReadImageCB" "', argument " "2"" of type '" "void *""'"); 
  }
  SbImage::addReadImageCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_removeReadImageCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImageReadImageCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbImage_removeReadImageCB", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbImage_removeReadImageCB" "', argument " "1"" of type '" "SbImageReadImageCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage_removeReadImageCB" "', argument " "2"" of type '" "void *""'"); 
  }
  SbImage::removeReadImageCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_searchForFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbString *arg1 = 0 ;
  SbString **arg2 = 0 ;
  int arg3 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SbString result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbImage_searchForFile", 3, 3, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0]))  
    {
      arg1 = new SbString(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg1 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg1 = *tmp;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbImage_searchForFile" "', argument " "2"" of type '" "SbString const *const *""'"); 
  }
  arg2 = reinterpret_cast< SbString ** >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbImage_searchForFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = SbImage::searchForFile((SbString const &)*arg1,(SbString const *const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_hasData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_hasData" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  result = (SbBool)((SbImage const *)arg1)->hasData();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_readLock" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  ((SbImage const *)arg1)->readLock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_readUnlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_readUnlock" "', argument " "1"" of type '" "SbImage const *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  ((SbImage const *)arg1)->readUnlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_scheduleReadFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbImageScheduleReadCB *arg2 = 0 ;
  void *arg3 = 0 ;
  SbString *arg4 = 0 ;
  SbString **arg5 = 0 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_scheduleReadFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbImage_scheduleReadFile" "', argument " "2"" of type '" "SbImageScheduleReadCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_scheduleReadFile" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    if (PyBytes_Check(swig_obj[3]))  
    {
      arg4 = new SbString(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg4 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg4 = *tmp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbImage_scheduleReadFile" "', argument " "5"" of type '" "SbString const *const *""'"); 
  }
  arg5 = reinterpret_cast< SbString ** >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SbImage_scheduleReadFile" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (SbBool)(arg1)->scheduleReadFile(arg2,arg3,(SbString const &)*arg4,(SbString const *const *)arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_scheduleReadFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbImageScheduleReadCB *arg2 = 0 ;
  void *arg3 = 0 ;
  SbString *arg4 = 0 ;
  SbString **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_scheduleReadFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbImage_scheduleReadFile" "', argument " "2"" of type '" "SbImageScheduleReadCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_scheduleReadFile" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    if (PyBytes_Check(swig_obj[3]))  
    {
      arg4 = new SbString(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg4 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg4 = *tmp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_p_SbString, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SbImage_scheduleReadFile" "', argument " "5"" of type '" "SbString const *const *""'"); 
  }
  arg5 = reinterpret_cast< SbString ** >(argp5);
  result = (SbBool)(arg1)->scheduleReadFile(arg2,arg3,(SbString const &)*arg4,(SbString const *const *)arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_scheduleReadFile__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  SbImageScheduleReadCB *arg2 = 0 ;
  void *arg3 = 0 ;
  SbString *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_scheduleReadFile" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbImage_scheduleReadFile" "', argument " "2"" of type '" "SbImageScheduleReadCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbImage_scheduleReadFile" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    if (PyBytes_Check(swig_obj[3]))  
    {
      arg4 = new SbString(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg4 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg4 = *tmp;
    }
  }
  result = (SbBool)(arg1)->scheduleReadFile(arg2,arg3,(SbString const &)*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_scheduleReadFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbImage_scheduleReadFile", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) &&
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            return _wrap_SbImage_scheduleReadFile__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) &&
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_SbString, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SbImage_scheduleReadFile__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            void *ptr = NULL;
            _v = 1;
            
            
            
            
            if (!PyBytes_Check(argv[3]) &&
              !PyUnicode_Check(argv[3]) && 
              (SWIG_ConvertPtr(argv[3], (void**)(&ptr), SWIGTYPE_p_SbString, 0) == -1))
            
            {
              _v = 0;
            }
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_SbString, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SbImage_scheduleReadFile__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbImage_scheduleReadFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::scheduleReadFile(SbImageScheduleReadCB *,void *,SbString const &,SbString const *const *,int const)\n"
    "    SbImage::scheduleReadFile(SbImageScheduleReadCB *,void *,SbString const &,SbString const *const *)\n"
    "    SbImage::scheduleReadFile(SbImageScheduleReadCB *,void *,SbString const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbImage_getValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbImage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbImage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbImage_getValue" "', argument " "1"" of type '" "SbImage *""'"); 
  }
  arg1 = reinterpret_cast< SbImage * >(argp1);
  result = (PyObject *)SbImage_getValue__SWIG_2(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbImage_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbImage_getValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbImage_getValue__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec3s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbImage_getValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbImage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbVec2s, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbImage_getValue__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbImage_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbImage::getValue(SbVec2s &,int &) const\n"
    "    SbImage::getValue(SbVec3s &,int &) const\n"
    "    SbImage::getValue()\n");
  return 0;
}


SWIGINTERN PyObject *SbImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbImage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_ptinsidefunc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  SbBool (*arg2)(void *const,SbVec3f const &) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTreeFuncs_ptinsidefunc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_ptinsidefunc_set" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbVec3f__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbOctTreeFuncs_ptinsidefunc_set" "', argument " "2"" of type '" "SbBool (*)(void *const,SbVec3f const &)""'"); 
    }
  }
  if (arg1) (arg1)->ptinsidefunc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_ptinsidefunc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool (*result)(void *const,SbVec3f const &) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_ptinsidefunc_get" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  result = (SbBool (*)(void *const,SbVec3f const &)) ((arg1)->ptinsidefunc);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbVec3f__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insideboxfunc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  SbBool (*arg2)(void *const,SbBox3f const &) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTreeFuncs_insideboxfunc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insideboxfunc_set" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbBox3f__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbOctTreeFuncs_insideboxfunc_set" "', argument " "2"" of type '" "SbBool (*)(void *const,SbBox3f const &)""'"); 
    }
  }
  if (arg1) (arg1)->insideboxfunc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insideboxfunc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool (*result)(void *const,SbBox3f const &) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insideboxfunc_get" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  result = (SbBool (*)(void *const,SbBox3f const &)) ((arg1)->insideboxfunc);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbBox3f__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insidespherefunc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  SbBool (*arg2)(void *const,SbSphere const &) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTreeFuncs_insidespherefunc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insidespherefunc_set" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbSphere__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbOctTreeFuncs_insidespherefunc_set" "', argument " "2"" of type '" "SbBool (*)(void *const,SbSphere const &)""'"); 
    }
  }
  if (arg1) (arg1)->insidespherefunc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insidespherefunc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool (*result)(void *const,SbSphere const &) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insidespherefunc_get" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  result = (SbBool (*)(void *const,SbSphere const &)) ((arg1)->insidespherefunc);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_q_const__p_void_r_q_const__SbSphere__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insideplanesfunc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  SbBool (*arg2)(void *const,SbPlane const *const,int const) = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTreeFuncs_insideplanesfunc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insideplanesfunc_set" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbOctTreeFuncs_insideplanesfunc_set" "', argument " "2"" of type '" "SbBool (*)(void *const,SbPlane const *const,int const)""'"); 
    }
  }
  if (arg1) (arg1)->insideplanesfunc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTreeFuncs_insideplanesfunc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool (*result)(void *const,SbPlane const *const,int const) = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTreeFuncs_insideplanesfunc_get" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  result = (SbBool (*)(void *const,SbPlane const *const,int const)) ((arg1)->insideplanesfunc);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbOctTreeFuncs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbOctTreeFuncs", 0, 0, 0)) SWIG_fail;
  result = (SbOctTreeFuncs *)new SbOctTreeFuncs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbOctTreeFuncs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbOctTreeFuncs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTreeFuncs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTreeFuncs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbOctTreeFuncs" "', argument " "1"" of type '" "SbOctTreeFuncs *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTreeFuncs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbOctTreeFuncs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbOctTreeFuncs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbOctTreeFuncs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbOctTree__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbOctTreeFuncs *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SbOctTree *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbOctTree" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbOctTree" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbOctTreeFuncs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbOctTree" "', argument " "2"" of type '" "SbOctTreeFuncs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbOctTree" "', argument " "2"" of type '" "SbOctTreeFuncs const &""'"); 
  }
  arg2 = reinterpret_cast< SbOctTreeFuncs * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SbOctTree" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (SbOctTree *)new SbOctTree((SbBox3f const &)*arg1,(SbOctTreeFuncs const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbOctTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbOctTree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBox3f *arg1 = 0 ;
  SbOctTreeFuncs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbOctTree *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbOctTree" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbOctTree" "', argument " "1"" of type '" "SbBox3f const &""'"); 
  }
  arg1 = reinterpret_cast< SbBox3f * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbOctTreeFuncs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbOctTree" "', argument " "2"" of type '" "SbOctTreeFuncs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SbOctTree" "', argument " "2"" of type '" "SbOctTreeFuncs const &""'"); 
  }
  arg2 = reinterpret_cast< SbOctTreeFuncs * >(argp2);
  result = (SbOctTree *)new SbOctTree((SbBox3f const &)*arg1,(SbOctTreeFuncs const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbOctTree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbOctTree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbOctTree", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbOctTreeFuncs, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SbOctTree__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbOctTreeFuncs, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SbOctTree__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbOctTree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbOctTree::SbOctTree(SbBox3f const &,SbOctTreeFuncs const &,int const)\n"
    "    SbOctTree::SbOctTree(SbBox3f const &,SbOctTreeFuncs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbOctTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbOctTree" "', argument " "1"" of type '" "SbOctTree *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_addItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTree_addItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_addItem" "', argument " "1"" of type '" "SbOctTree *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_addItem" "', argument " "2"" of type '" "void *const""'"); 
  }
  (arg1)->addItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_removeItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  void *arg2 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTree_removeItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_removeItem" "', argument " "1"" of type '" "SbOctTree *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_removeItem" "', argument " "2"" of type '" "void *const""'"); 
  }
  (arg1)->removeItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ((SbOctTree const *)arg1)->findItems((SbVec3f const &)*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ((SbOctTree const *)arg1)->findItems((SbVec3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ((SbOctTree const *)arg1)->findItems((SbBox3f const &)*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbBox3f *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbBox3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbBox3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbBox3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ((SbOctTree const *)arg1)->findItems((SbBox3f const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ((SbOctTree const *)arg1)->findItems((SbSphere const &)*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbSphere *arg2 = 0 ;
  SbList< void * > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbSphere,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbSphere const &""'"); 
  }
  arg2 = reinterpret_cast< SbSphere * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "SbList< void * > &""'"); 
  }
  arg3 = reinterpret_cast< SbList< void * > * >(argp3);
  ((SbOctTree const *)arg1)->findItems((SbSphere const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbPlane *arg2 = (SbPlane *)0 ;
  int arg3 ;
  SbList< void * > *arg4 = 0 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbPlane const *const""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbList< void * > &""'"); 
  }
  arg4 = reinterpret_cast< SbList< void * > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SbOctTree_findItems" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  ((SbOctTree const *)arg1)->findItems((SbPlane const *)arg2,arg3,*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  SbPlane *arg2 = (SbPlane *)0 ;
  int arg3 ;
  SbList< void * > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_findItems" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SbPlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbOctTree_findItems" "', argument " "2"" of type '" "SbPlane const *const""'"); 
  }
  arg2 = reinterpret_cast< SbPlane * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbOctTree_findItems" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbListT_void_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbList< void * > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbOctTree_findItems" "', argument " "4"" of type '" "SbList< void * > &""'"); 
  }
  arg4 = reinterpret_cast< SbList< void * > * >(argp4);
  ((SbOctTree const *)arg1)->findItems((SbPlane const *)arg2,arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_findItems(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbOctTree_findItems", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbOctTree_findItems__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbOctTree_findItems__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbOctTree_findItems__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbOctTree_findItems__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbSphere, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbOctTree_findItems__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbBox3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SbOctTree_findItems__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbPlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SbOctTree_findItems__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbOctTree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SbPlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SbListT_void_p_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SbOctTree_findItems__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbOctTree_findItems'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbOctTree::findItems(SbVec3f const &,SbList< void * > &,SbBool const) const\n"
    "    SbOctTree::findItems(SbVec3f const &,SbList< void * > &) const\n"
    "    SbOctTree::findItems(SbBox3f const &,SbList< void * > &,SbBool const) const\n"
    "    SbOctTree::findItems(SbBox3f const &,SbList< void * > &) const\n"
    "    SbOctTree::findItems(SbSphere const &,SbList< void * > &,SbBool const) const\n"
    "    SbOctTree::findItems(SbSphere const &,SbList< void * > &) const\n"
    "    SbOctTree::findItems(SbPlane const *const,int const,SbList< void * > &,SbBool const) const\n"
    "    SbOctTree::findItems(SbPlane const *const,int const,SbList< void * > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbOctTree_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBox3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_getBoundingBox" "', argument " "1"" of type '" "SbOctTree const *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  result = (SbBox3f *) &((SbOctTree const *)arg1)->getBoundingBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBox3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_clear" "', argument " "1"" of type '" "SbOctTree *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbOctTree_debugTree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbOctTree *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbOctTree_debugTree", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbOctTree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbOctTree_debugTree" "', argument " "1"" of type '" "SbOctTree *""'"); 
  }
  arg1 = reinterpret_cast< SbOctTree * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  (arg1)->debugTree(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbOctTree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbOctTree, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbOctTree_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbTesselator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTesselatorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  SbTesselator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_SbTesselator" "', argument " "1"" of type '" "SbTesselatorCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SbTesselator *)new SbTesselator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTesselator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTesselator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTesselatorCB *arg1 = 0 ;
  SbTesselator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_SbTesselator" "', argument " "1"" of type '" "SbTesselatorCB *""'"); 
    }
  }
  result = (SbTesselator *)new SbTesselator(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTesselator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTesselator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SbTesselator *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SbTesselator *)new SbTesselator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTesselator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbTesselator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbTesselator", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SbTesselator__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbTesselator__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *ptr = 0;
    int res = SWIG_ConvertFunctionPtr(argv[0], &ptr, SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyTuple_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_SbTesselator__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbTesselator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTesselator::SbTesselator(SbTesselatorCB *,void *)\n"
    "    SbTesselator::SbTesselator(SbTesselatorCB *)\n"
    "    SbTesselator::SbTesselator()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbTesselator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbTesselator" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_beginPolygon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  SbBool arg2 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_beginPolygon" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTesselator_beginPolygon" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbTesselator_beginPolygon" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbTesselator_beginPolygon" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->beginPolygon(arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_beginPolygon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_beginPolygon" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SbTesselator_beginPolygon" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->beginPolygon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_beginPolygon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_beginPolygon" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  (arg1)->beginPolygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_beginPolygon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbTesselator_beginPolygon", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTesselator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbTesselator_beginPolygon__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTesselator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SbTesselator_beginPolygon__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbTesselator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SbTesselator_beginPolygon__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbTesselator_beginPolygon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbTesselator::beginPolygon(SbBool,SbVec3f const &)\n"
    "    SbTesselator::beginPolygon(SbBool)\n"
    "    SbTesselator::beginPolygon()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SbTesselator_addVertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTesselator_addVertex", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_addVertex" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbTesselator_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbTesselator_addVertex" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addVertex((SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_endPolygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_endPolygon" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  (arg1)->endPolygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbTesselator_setCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTesselator *arg1 = 0 ;
  SbTesselatorCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbTesselator_setCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbTesselator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbTesselator_setCallback" "', argument " "1"" of type '" "SbTesselator *""'"); 
  }
  arg1 = reinterpret_cast< SbTesselator * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbTesselator_setCallback" "', argument " "2"" of type '" "SbTesselatorCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->setCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbTesselator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbTesselator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbTesselator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTimerQueueSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTimerQueueSensor", 0, 0, 0)) SWIG_fail;
  result = (SoTimerQueueSensor *)new SoTimerQueueSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTimerQueueSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTimerQueueSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoTimerQueueSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTimerQueueSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoTimerQueueSensor *)new SoTimerQueueSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTimerQueueSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTimerQueueSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTimerQueueSensor" "', argument " "1"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerQueueSensor_getTriggerTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerQueueSensor_getTriggerTime" "', argument " "1"" of type '" "SoTimerQueueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  result = (SbTime *) &((SoTimerQueueSensor const *)arg1)->getTriggerTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerQueueSensor_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerQueueSensor_schedule" "', argument " "1"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  (arg1)->schedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerQueueSensor_unschedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerQueueSensor_unschedule" "', argument " "1"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  (arg1)->unschedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerQueueSensor_isScheduled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerQueueSensor_isScheduled" "', argument " "1"" of type '" "SoTimerQueueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  result = (SbBool)((SoTimerQueueSensor const *)arg1)->isScheduled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerQueueSensor_trigger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerQueueSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerQueueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerQueueSensor_trigger" "', argument " "1"" of type '" "SoTimerQueueSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerQueueSensor * >(argp1);
  (arg1)->trigger();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoTimerQueueSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTimerQueueSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTimerQueueSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoAlarmSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAlarmSensor", 0, 0, 0)) SWIG_fail;
  result = (SoAlarmSensor *)new SoAlarmSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAlarmSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoAlarmSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoAlarmSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoAlarmSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoAlarmSensor *)new SoAlarmSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAlarmSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoAlarmSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlarmSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoAlarmSensor" "', argument " "1"" of type '" "SoAlarmSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoAlarmSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlarmSensor_setTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlarmSensor_setTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlarmSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlarmSensor_setTime" "', argument " "1"" of type '" "SoAlarmSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoAlarmSensor * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setTime((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlarmSensor_setTimeFromNow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoAlarmSensor_setTimeFromNow", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlarmSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlarmSensor_setTimeFromNow" "', argument " "1"" of type '" "SoAlarmSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoAlarmSensor * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setTimeFromNow((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlarmSensor_getTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlarmSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlarmSensor_getTime" "', argument " "1"" of type '" "SoAlarmSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoAlarmSensor * >(argp1);
  result = (SbTime *) &((SoAlarmSensor const *)arg1)->getTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoAlarmSensor_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoAlarmSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoAlarmSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoAlarmSensor_schedule" "', argument " "1"" of type '" "SoAlarmSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoAlarmSensor * >(argp1);
  (arg1)->schedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoAlarmSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoAlarmSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoAlarmSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoIdleSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIdleSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIdleSensor", 0, 0, 0)) SWIG_fail;
  result = (SoIdleSensor *)new SoIdleSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIdleSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoIdleSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoIdleSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoIdleSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoIdleSensor *)new SoIdleSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoIdleSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoIdleSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoIdleSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoIdleSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoIdleSensor" "', argument " "1"" of type '" "SoIdleSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoIdleSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoIdleSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoIdleSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoIdleSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoNodeSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodeSensor", 0, 0, 0)) SWIG_fail;
  result = (SoNodeSensor *)new SoNodeSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoNodeSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNodeSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoNodeSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoNodeSensor *)new SoNodeSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoNodeSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoNodeSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoNodeSensor" "', argument " "1"" of type '" "SoNodeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeSensor_attach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeSensor *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoNodeSensor_attach", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeSensor_attach" "', argument " "1"" of type '" "SoNodeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoNodeSensor_attach" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->attach(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeSensor_detach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeSensor_detach" "', argument " "1"" of type '" "SoNodeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeSensor * >(argp1);
  (arg1)->detach();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoNodeSensor_getAttachedNode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoNodeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNodeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoNodeSensor_getAttachedNode" "', argument " "1"" of type '" "SoNodeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoNodeSensor * >(argp1);
  result = (SoNode *)((SoNodeSensor const *)arg1)->getAttachedNode();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoNodeSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoNodeSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoNodeSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoOneShotSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShotSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoOneShotSensor", 0, 0, 0)) SWIG_fail;
  result = (SoOneShotSensor *)new SoOneShotSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOneShotSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOneShotSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoOneShotSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoOneShotSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoOneShotSensor *)new SoOneShotSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOneShotSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoOneShotSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOneShotSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOneShotSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoOneShotSensor" "', argument " "1"" of type '" "SoOneShotSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoOneShotSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoOneShotSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOneShotSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOneShotSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPathSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPathSensor", 0, 0, 0)) SWIG_fail;
  result = (SoPathSensor *)new SoPathSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPathSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoPathSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoPathSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoPathSensor *)new SoPathSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPathSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoPathSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPathSensor" "', argument " "1"" of type '" "SoPathSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSensor_setTriggerFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  SoPathSensor::TriggerFilter arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSensor_setTriggerFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSensor_setTriggerFilter" "', argument " "1"" of type '" "SoPathSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPathSensor_setTriggerFilter" "', argument " "2"" of type '" "SoPathSensor::TriggerFilter""'");
  } 
  arg2 = static_cast< SoPathSensor::TriggerFilter >(val2);
  (arg1)->setTriggerFilter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSensor_getTriggerFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPathSensor::TriggerFilter result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSensor_getTriggerFilter" "', argument " "1"" of type '" "SoPathSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  result = (SoPathSensor::TriggerFilter)((SoPathSensor const *)arg1)->getTriggerFilter();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSensor_attach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPathSensor_attach", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSensor_attach" "', argument " "1"" of type '" "SoPathSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPathSensor_attach" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  (arg1)->attach(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSensor_detach(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSensor_detach" "', argument " "1"" of type '" "SoPathSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  (arg1)->detach();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPathSensor_getAttachedPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPathSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPathSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPathSensor_getAttachedPath" "', argument " "1"" of type '" "SoPathSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoPathSensor * >(argp1);
  result = (SoPath *)((SoPathSensor const *)arg1)->getAttachedPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPathSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPathSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPathSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoTimerSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTimerSensor", 0, 0, 0)) SWIG_fail;
  result = (SoTimerSensor *)new SoTimerSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTimerSensor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoTimerSensor_scb_v(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSensorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  PyObject *swig_obj[2] ;
  SoTimerSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoTimerSensor_scb_v", 2, 2, swig_obj)) SWIG_fail;
  {
    if (!PyCallable_Check(swig_obj[0])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg1 = SoSensorPythonCB;
  }
  {
    if (!PyTuple_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[1]);
    arg2 = (void *)swig_obj[1];
  }
  result = (SoTimerSensor *)new SoTimerSensor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoTimerSensor, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoTimerSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoTimerSensor" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_setBaseTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimerSensor_setBaseTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_setBaseTime" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setBaseTime((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_getBaseTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_getBaseTime" "', argument " "1"" of type '" "SoTimerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  result = (SbTime *) &((SoTimerSensor const *)arg1)->getBaseTime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_setInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimerSensor_setInterval", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_setInterval" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setInterval((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_getInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_getInterval" "', argument " "1"" of type '" "SoTimerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  result = (SbTime *) &((SoTimerSensor const *)arg1)->getInterval();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_schedule" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  (arg1)->schedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_unschedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_unschedule" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  (arg1)->unschedule();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoTimerSensor_reschedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoTimerSensor *arg1 = 0 ;
  SbTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoTimerSensor_reschedule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoTimerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoTimerSensor_reschedule" "', argument " "1"" of type '" "SoTimerSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoTimerSensor * >(argp1);
  {
    if (PyFloat_Check(swig_obj[1])) {
      arg2 = new SbTime(PyFloat_AsDouble(swig_obj[1]));
    } else {
      SbTime * tmp = NULL;
      arg2 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->reschedule((SbTime const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *SoTimerSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoTimerSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoTimerSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoInteraction_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoInteraction_init", 0, 0, 0)) SWIG_fail;
  SoInteraction::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoInteraction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteraction *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoInteraction", 0, 0, 0)) SWIG_fail;
  result = (SoInteraction *)new SoInteraction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoInteraction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoInteraction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoInteraction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoInteraction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoInteraction" "', argument " "1"" of type '" "SoInteraction *""'"); 
  }
  arg1 = reinterpret_cast< SoInteraction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoInteraction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoInteraction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoInteraction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoOffscreenRenderer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbViewportRegion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoOffscreenRenderer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoOffscreenRenderer" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoOffscreenRenderer" "', argument " "1"" of type '" "SbViewportRegion const &""'"); 
  }
  arg1 = reinterpret_cast< SbViewportRegion * >(argp1);
  result = (SoOffscreenRenderer *)new SoOffscreenRenderer((SbViewportRegion const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOffscreenRenderer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOffscreenRenderer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoGLRenderAction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoOffscreenRenderer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoOffscreenRenderer" "', argument " "1"" of type '" "SoGLRenderAction *""'"); 
  }
  arg1 = reinterpret_cast< SoGLRenderAction * >(argp1);
  result = (SoOffscreenRenderer *)new SoOffscreenRenderer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoOffscreenRenderer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoOffscreenRenderer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoOffscreenRenderer", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SbViewportRegion, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoOffscreenRenderer__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoOffscreenRenderer__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoOffscreenRenderer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOffscreenRenderer::SoOffscreenRenderer(SbViewportRegion const &)\n"
    "    SoOffscreenRenderer::SoOffscreenRenderer(SoGLRenderAction *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoOffscreenRenderer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoOffscreenRenderer" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getScreenPixelsPerInch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_getScreenPixelsPerInch", 0, 0, 0)) SWIG_fail;
  result = (float)SoOffscreenRenderer::getScreenPixelsPerInch();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getMaximumResolution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbVec2s result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_getMaximumResolution", 0, 0, 0)) SWIG_fail;
  result = SoOffscreenRenderer::getMaximumResolution();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_setComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SoOffscreenRenderer::Components arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_setComponents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_setComponents" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOffscreenRenderer_setComponents" "', argument " "2"" of type '" "SoOffscreenRenderer::Components""'");
  } 
  arg2 = static_cast< SoOffscreenRenderer::Components >(val2);
  (arg1)->setComponents(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getComponents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoOffscreenRenderer::Components result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getComponents" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (SoOffscreenRenderer::Components)((SoOffscreenRenderer const *)arg1)->getComponents();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_setViewportRegion" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOffscreenRenderer_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getViewportRegion" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (SbViewportRegion *) &((SoOffscreenRenderer const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_setBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_setBackgroundColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_setBackgroundColor" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_setBackgroundColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOffscreenRenderer_setBackgroundColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setBackgroundColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getBackgroundColor" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (SbColor *) &((SoOffscreenRenderer const *)arg1)->getBackgroundColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_setGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_setGLRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_setGLRenderAction" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_setGLRenderAction" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->setGLRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getGLRenderAction" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (SoGLRenderAction *)((SoOffscreenRenderer const *)arg1)->getGLRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_render__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_render" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_render" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbBool)(arg1)->render(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_render__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_render" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_render" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  result = (SbBool)(arg1)->render(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_render(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_render", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_render__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoPath, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_render__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOffscreenRenderer_render'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOffscreenRenderer::render(SoNode *)\n"
    "    SoOffscreenRenderer::render(SoPath *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getBuffer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getBuffer" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (unsigned char *)((SoOffscreenRenderer const *)arg1)->getBuffer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getDC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getDC" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (void **) &((SoOffscreenRenderer const *)arg1)->getDC();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(*result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToRGB__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToRGB" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToRGB(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToPostScript__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  FILE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToPostScript(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToPostScript__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  FILE *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  {
    if (PyObject_IsInstance(swig_obj[1], PyIOBase_TypeObj)) {
      int fd = PyObject_AsFileDescriptor(swig_obj[1]);
      arg2 = fdopen(fd, "w");
    }
    
    else {
      PyErr_SetString(PyExc_TypeError, "expected a file object.");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToPostScript(arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToRGB__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToRGB" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_writeToRGB" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToRGB((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToRGB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_writeToRGB", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_writeToRGB__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_writeToRGB__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOffscreenRenderer_writeToRGB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOffscreenRenderer::writeToRGB(FILE *) const\n"
    "    SoOffscreenRenderer::writeToRGB(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToPostScript__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToPostScript((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToPostScript__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  char *arg2 = 0 ;
  SbVec2f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOffscreenRenderer_writeToPostScript" "', argument " "3"" of type '" "SbVec2f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec2f * >(argp3);
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToPostScript((char const *)arg2,(SbVec2f const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToPostScript(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_writeToPostScript", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_writeToPostScript__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoOffscreenRenderer_writeToPostScript__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoOffscreenRenderer_writeToPostScript__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoOffscreenRenderer_writeToPostScript__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOffscreenRenderer_writeToPostScript'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOffscreenRenderer::writeToPostScript(FILE *) const\n"
    "    SoOffscreenRenderer::writeToPostScript(FILE *,SbVec2f const &) const\n"
    "    SoOffscreenRenderer::writeToPostScript(char const *) const\n"
    "    SoOffscreenRenderer::writeToPostScript(char const *,SbVec2f const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_isWriteSupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_isWriteSupported", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_isWriteSupported" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->isWriteSupported((SbName const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getNumWriteFiletypes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getNumWriteFiletypes" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (int)((SoOffscreenRenderer const *)arg1)->getNumWriteFiletypes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getWriteFiletypeInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  int arg2 ;
  SbPList *arg3 = 0 ;
  SbString *arg4 = 0 ;
  SbString *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_getWriteFiletypeInfo", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getWriteFiletypeInfo" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOffscreenRenderer_getWriteFiletypeInfo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoOffscreenRenderer_getWriteFiletypeInfo" "', argument " "3"" of type '" "SbPList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoOffscreenRenderer_getWriteFiletypeInfo" "', argument " "3"" of type '" "SbPList &""'"); 
  }
  arg3 = reinterpret_cast< SbPList * >(argp3);
  {
    if (PyBytes_Check(swig_obj[3]))  
    {
      arg4 = new SbString(PyBytes_AsString(swig_obj[3]));
    }
    else if  (PyUnicode_Check(swig_obj[3])){
      arg4 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[3], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg4 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg4 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[4]))  
    {
      arg5 = new SbString(PyBytes_AsString(swig_obj[4]));
    }
    else if  (PyUnicode_Check(swig_obj[4])){
      arg5 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[4], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg5 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[4], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg5 = *tmp;
    }
  }
  (arg1)->getWriteFiletypeInfo(arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  {
    if (arg5) {
      delete arg5; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_writeToFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SbString *arg2 = 0 ;
  SbName *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_writeToFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_writeToFile" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  {
    if (PyBytes_Check(swig_obj[2]))
    {
      arg3 = new SbName(PyBytes_AsString(swig_obj[2]));
    }
    else if  (PyUnicode_Check(swig_obj[2])){
      arg3 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[2], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg3 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[2], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg3 = *tmp;
    }
  }
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->writeToFile((SbString const &)*arg2,(SbName const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  {
    if (arg3) {
      delete arg3; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_setPbufferEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_setPbufferEnable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_setPbufferEnable" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoOffscreenRenderer_setPbufferEnable" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setPbufferEnable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getPbufferEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getPbufferEnable" "', argument " "1"" of type '" "SoOffscreenRenderer const *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (SbBool)((SoOffscreenRenderer const *)arg1)->getPbufferEnable();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getBuffer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoOffscreenRenderer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoOffscreenRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoOffscreenRenderer_getBuffer" "', argument " "1"" of type '" "SoOffscreenRenderer *""'"); 
  }
  arg1 = reinterpret_cast< SoOffscreenRenderer * >(argp1);
  result = (PyObject *)SoOffscreenRenderer_getBuffer__SWIG_1(arg1);
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoOffscreenRenderer_getBuffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoOffscreenRenderer_getBuffer", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoOffscreenRenderer_getBuffer__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoOffscreenRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoOffscreenRenderer_getBuffer__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoOffscreenRenderer_getBuffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoOffscreenRenderer::getBuffer() const\n"
    "    SoOffscreenRenderer::getBuffer()\n");
  return 0;
}


SWIGINTERN PyObject *SoOffscreenRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoOffscreenRenderer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoOffscreenRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPickedPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoPickedPoint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPickedPoint" "', argument " "1"" of type '" "SoPickedPoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPickedPoint" "', argument " "1"" of type '" "SoPickedPoint const &""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SoPickedPoint *)new SoPickedPoint((SoPickedPoint const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickedPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPath *arg1 = (SoPath *)0 ;
  SoState *arg2 = (SoState *)0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPickedPoint" "', argument " "1"" of type '" "SoPath const *const""'"); 
  }
  arg1 = reinterpret_cast< SoPath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoPickedPoint" "', argument " "2"" of type '" "SoState *const""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SoPickedPoint" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPickedPoint" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  result = (SoPickedPoint *)new SoPickedPoint((SoPath const *)arg1,arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPickedPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPickedPoint", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoPickedPoint, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPickedPoint__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SoPickedPoint__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPickedPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::SoPickedPoint(SoPickedPoint const &)\n"
    "    SoPickedPoint::SoPickedPoint(SoPath const *const,SoState *const,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoPickedPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPickedPoint" "', argument " "1"" of type '" "SoPickedPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPickedPoint *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_copy" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SoPickedPoint *)((SoPickedPoint const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getPoint" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbVec3f *) &((SoPickedPoint const *)arg1)->getPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getNormal" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbVec3f *) &((SoPickedPoint const *)arg1)->getNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getTextureCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getTextureCoords" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbVec4f *) &((SoPickedPoint const *)arg1)->getTextureCoords();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getMaterialIndex" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (int)((SoPickedPoint const *)arg1)->getMaterialIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoPath *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getPath" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SoPath *)((SoPickedPoint const *)arg1)->getPath();
  {
    resultobj = autocast_path(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_isOnGeometry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_isOnGeometry" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbBool)((SoPickedPoint const *)arg1)->isOnGeometry();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getDetail__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SoDetail *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getDetail" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getDetail" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SoDetail *)((SoPickedPoint const *)arg1)->getDetail((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getDetail__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoDetail *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getDetail" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SoDetail *)((SoPickedPoint const *)arg1)->getDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getDetail(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getDetail", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getDetail__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getDetail__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getDetail'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getDetail(SoNode const *const) const\n"
    "    SoPickedPoint::getDetail() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToWorld__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectToWorld" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getObjectToWorld" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getObjectToWorld((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToWorld__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectToWorld" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getObjectToWorld();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToWorld(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getObjectToWorld", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getObjectToWorld__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getObjectToWorld__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getObjectToWorld'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getObjectToWorld(SoNode const *const) const\n"
    "    SoPickedPoint::getObjectToWorld() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getWorldToObject__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getWorldToObject" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getWorldToObject" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getWorldToObject((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getWorldToObject__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getWorldToObject" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getWorldToObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getWorldToObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getWorldToObject", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getWorldToObject__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getWorldToObject__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getWorldToObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getWorldToObject(SoNode const *const) const\n"
    "    SoPickedPoint::getWorldToObject() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToImage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectToImage" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getObjectToImage" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getObjectToImage((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToImage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectToImage" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getObjectToImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectToImage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getObjectToImage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getObjectToImage__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getObjectToImage__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getObjectToImage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getObjectToImage(SoNode const *const) const\n"
    "    SoPickedPoint::getObjectToImage() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getImageToObject__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getImageToObject" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getImageToObject" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getImageToObject((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getImageToObject__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbMatrix *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getImageToObject" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = (SbMatrix *) &((SoPickedPoint const *)arg1)->getImageToObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMatrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getImageToObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getImageToObject", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getImageToObject__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getImageToObject__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getImageToObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getImageToObject(SoNode const *const) const\n"
    "    SoPickedPoint::getImageToObject() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectPoint" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getObjectPoint" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = ((SoPickedPoint const *)arg1)->getObjectPoint((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectPoint" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = ((SoPickedPoint const *)arg1)->getObjectPoint();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getObjectPoint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getObjectPoint__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getObjectPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getObjectPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getObjectPoint(SoNode const *const) const\n"
    "    SoPickedPoint::getObjectPoint() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectNormal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectNormal" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getObjectNormal" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = ((SoPickedPoint const *)arg1)->getObjectNormal((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectNormal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec3f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectNormal" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = ((SoPickedPoint const *)arg1)->getObjectNormal();
  resultobj = SWIG_NewPointerObj((new SbVec3f(result)), SWIGTYPE_p_SbVec3f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectNormal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getObjectNormal", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getObjectNormal__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getObjectNormal__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getObjectNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getObjectNormal(SoNode const *const) const\n"
    "    SoPickedPoint::getObjectNormal() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectTextureCoords__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbVec4f result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectTextureCoords" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_getObjectTextureCoords" "', argument " "2"" of type '" "SoNode const *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = ((SoPickedPoint const *)arg1)->getObjectTextureCoords((SoNode const *)arg2);
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectTextureCoords__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbVec4f result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_getObjectTextureCoords" "', argument " "1"" of type '" "SoPickedPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  result = ((SoPickedPoint const *)arg1)->getObjectTextureCoords();
  resultobj = SWIG_NewPointerObj((new SbVec4f(result)), SWIGTYPE_p_SbVec4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_getObjectTextureCoords(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPickedPoint_getObjectTextureCoords", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoPickedPoint_getObjectTextureCoords__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPickedPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPickedPoint_getObjectTextureCoords__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPickedPoint_getObjectTextureCoords'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPickedPoint::getObjectTextureCoords(SoNode const *const) const\n"
    "    SoPickedPoint::getObjectTextureCoords() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_setObjectNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPoint_setObjectNormal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_setObjectNormal" "', argument " "1"" of type '" "SoPickedPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_setObjectNormal" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickedPoint_setObjectNormal" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setObjectNormal((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_setObjectTextureCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPoint_setObjectTextureCoords", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_setObjectTextureCoords" "', argument " "1"" of type '" "SoPickedPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_setObjectTextureCoords" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPickedPoint_setObjectTextureCoords" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setObjectTextureCoords((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_setMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPoint_setMaterialIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_setMaterialIndex" "', argument " "1"" of type '" "SoPickedPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPickedPoint_setMaterialIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMaterialIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPickedPoint_setDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPickedPoint *arg1 = 0 ;
  SoDetail *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPickedPoint_setDetail", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPickedPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPickedPoint_setDetail" "', argument " "1"" of type '" "SoPickedPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoPickedPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPickedPoint_setDetail" "', argument " "2"" of type '" "SoDetail *""'"); 
  }
  arg2 = reinterpret_cast< SoDetail * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoPickedPoint_setDetail" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->setDetail(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPickedPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPickedPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPickedPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoPrimitiveVertex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoPrimitiveVertex *)new SoPrimitiveVertex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPrimitiveVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPrimitiveVertex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SoPrimitiveVertex *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SoPrimitiveVertex,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoPrimitiveVertex" "', argument " "1"" of type '" "SoPrimitiveVertex const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SoPrimitiveVertex" "', argument " "1"" of type '" "SoPrimitiveVertex const &""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (SoPrimitiveVertex *)new SoPrimitiveVertex((SoPrimitiveVertex const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoPrimitiveVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoPrimitiveVertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoPrimitiveVertex", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoPrimitiveVertex__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoPrimitiveVertex, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoPrimitiveVertex__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoPrimitiveVertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPrimitiveVertex::SoPrimitiveVertex()\n"
    "    SoPrimitiveVertex::SoPrimitiveVertex(SoPrimitiveVertex const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SoPrimitiveVertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoPrimitiveVertex" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getPoint" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (SbVec3f *) &((SoPrimitiveVertex const *)arg1)->getPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getNormal" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (SbVec3f *) &((SoPrimitiveVertex const *)arg1)->getNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getTextureCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (SbVec4f *) &((SoPrimitiveVertex const *)arg1)->getTextureCoords();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getMaterialIndex" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (int)((SoPrimitiveVertex const *)arg1)->getMaterialIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getPackedColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getPackedColor" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (uint32_t)((SoPrimitiveVertex const *)arg1)->getPackedColor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_getDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDetail *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_getDetail" "', argument " "1"" of type '" "SoPrimitiveVertex const *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  result = (SoDetail *)((SoPrimitiveVertex const *)arg1)->getDetail();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDetail, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPrimitiveVertex_setPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setPoint((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPrimitiveVertex_setPoint" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setPoint(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setPoint", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPrimitiveVertex_setPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoPrimitiveVertex_setPoint__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPrimitiveVertex_setPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPrimitiveVertex::setPoint(SbVec3f const &)\n"
    "    SoPrimitiveVertex::setPoint(float,float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setNormal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPrimitiveVertex_setNormal" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setNormal((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setNormal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPrimitiveVertex_setNormal" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setNormal(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setNormal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setNormal", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPrimitiveVertex_setNormal__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoPrimitiveVertex_setNormal__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPrimitiveVertex_setNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPrimitiveVertex::setNormal(SbVec3f const &)\n"
    "    SoPrimitiveVertex::setNormal(float,float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SbVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec2f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  (arg1)->setTextureCoords((SbVec2f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setTextureCoords(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setTextureCoords((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setTextureCoords(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SbVec4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "SbVec4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec4f * >(argp2);
  (arg1)->setTextureCoords((SbVec4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoPrimitiveVertex_setTextureCoords" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setTextureCoords(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setTextureCoords(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setTextureCoords", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec2f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec4f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoPrimitiveVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoPrimitiveVertex_setTextureCoords__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoPrimitiveVertex_setTextureCoords'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoPrimitiveVertex::setTextureCoords(SbVec2f const &)\n"
    "    SoPrimitiveVertex::setTextureCoords(float,float)\n"
    "    SoPrimitiveVertex::setTextureCoords(SbVec3f const &)\n"
    "    SoPrimitiveVertex::setTextureCoords(float,float,float)\n"
    "    SoPrimitiveVertex::setTextureCoords(SbVec4f const &)\n"
    "    SoPrimitiveVertex::setTextureCoords(float,float,float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setMaterialIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setMaterialIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setMaterialIndex" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setMaterialIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMaterialIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setPackedColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setPackedColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setPackedColor" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoPrimitiveVertex_setPackedColor" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setPackedColor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoPrimitiveVertex_setDetail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoPrimitiveVertex *arg1 = 0 ;
  SoDetail *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoPrimitiveVertex_setDetail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoPrimitiveVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoPrimitiveVertex_setDetail" "', argument " "1"" of type '" "SoPrimitiveVertex *""'"); 
  }
  arg1 = reinterpret_cast< SoPrimitiveVertex * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoDetail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoPrimitiveVertex_setDetail" "', argument " "2"" of type '" "SoDetail *""'"); 
  }
  arg2 = reinterpret_cast< SoDetail * >(argp2);
  (arg1)->setDetail(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoPrimitiveVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoPrimitiveVertex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoPrimitiveVertex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoSceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoSceneManager", 0, 0, 0)) SWIG_fail;
  result = (SoSceneManager *)new SoSceneManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoSceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoSceneManager" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSceneManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->render(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  (arg1)->render();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSceneManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSceneManager_render" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoSceneManager_render" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  (arg1)->render(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSceneManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoSceneManager_render" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  (arg1)->render(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSceneManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->render(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_render" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_render(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSceneManager_render", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoSceneManager_render__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSceneManager_render__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoSceneManager_render__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSceneManager_render__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoSceneManager_render__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoSceneManager_render__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoSceneManager_render__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSceneManager_render'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSceneManager::render(SbBool const,SbBool const)\n"
    "    SoSceneManager::render(SbBool const)\n"
    "    SoSceneManager::render()\n"
    "    SoSceneManager::render(SoGLRenderAction *,SbBool const,SbBool const,SbBool const)\n"
    "    SoSceneManager::render(SoGLRenderAction *,SbBool const,SbBool const)\n"
    "    SoSceneManager::render(SoGLRenderAction *,SbBool const)\n"
    "    SoSceneManager::render(SoGLRenderAction *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoCamera *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setCamera" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setCamera" "', argument " "2"" of type '" "SoCamera *""'"); 
  }
  arg2 = reinterpret_cast< SoCamera * >(argp2);
  (arg1)->setCamera(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCamera *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getCamera" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SoCamera *)((SoSceneManager const *)arg1)->getCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_processEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoEvent *arg2 = (SoEvent *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_processEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_processEvent" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_processEvent" "', argument " "2"" of type '" "SoEvent const *const""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  result = (SbBool)(arg1)->processEvent((SoEvent const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_reinitialize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_reinitialize" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  (arg1)->reinitialize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_scheduleRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_scheduleRedraw" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  (arg1)->scheduleRedraw();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setSceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setSceneGraph" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setSceneGraph" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getSceneGraph" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SoNode *)((SoSceneManager const *)arg1)->getSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setWindowSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setWindowSize" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setWindowSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_setWindowSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setWindowSize((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getWindowSize" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbVec2s *) &((SoSceneManager const *)arg1)->getWindowSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setSize" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setSize((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getSize" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbVec2s *) &((SoSceneManager const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setOrigin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setOrigin" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setOrigin((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getOrigin" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbVec2s *) &((SoSceneManager const *)arg1)->getOrigin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setViewportRegion" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getViewportRegion" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbViewportRegion *) &((SoSceneManager const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setBackgroundColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setBackgroundColor" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setBackgroundColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_setBackgroundColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setBackgroundColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getBackgroundColor" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbColor *) &((SoSceneManager const *)arg1)->getBackgroundColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setBackgroundIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setBackgroundIndex" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_setBackgroundIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setBackgroundIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getBackgroundIndex" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (int)((SoSceneManager const *)arg1)->getBackgroundIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRGBMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setRGBMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRGBMode" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_setRGBMode" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setRGBMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_isRGBMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_isRGBMode" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbBool)((SoSceneManager const *)arg1)->isRGBMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_activate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_activate" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  (arg1)->activate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_deactivate" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoSceneManagerRenderCB *arg2 = 0 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRenderCallback" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSceneManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSceneManager_setRenderCallback" "', argument " "2"" of type '" "SoSceneManagerRenderCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSceneManager_setRenderCallback" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoSceneManagerRenderCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRenderCallback" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoSceneManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoSceneManager_setRenderCallback" "', argument " "2"" of type '" "SoSceneManagerRenderCB *""'"); 
    }
  }
  (arg1)->setRenderCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_isAutoRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_isAutoRedraw" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SbBool)((SoSceneManager const *)arg1)->isAutoRedraw();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setRedrawPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRedrawPriority" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_setRedrawPriority" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setRedrawPriority(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getRedrawPriority" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (uint32_t)((SoSceneManager const *)arg1)->getRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbBool arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setAntialiasing" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoSceneManager_setAntialiasing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoSceneManager_setAntialiasing" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setAntialiasing(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_getAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getAntialiasing" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_getAntialiasing" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_getAntialiasing" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoSceneManager_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoSceneManager_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ((SoSceneManager const *)arg1)->getAntialiasing(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = (SoGLRenderAction *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setGLRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setGLRenderAction" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setGLRenderAction" "', argument " "2"" of type '" "SoGLRenderAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->setGLRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getGLRenderAction" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SoGLRenderAction *)((SoSceneManager const *)arg1)->getGLRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoAudioRenderAction *arg2 = (SoAudioRenderAction *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setAudioRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setAudioRenderAction" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setAudioRenderAction" "', argument " "2"" of type '" "SoAudioRenderAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->setAudioRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAudioRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getAudioRenderAction" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SoAudioRenderAction *)((SoSceneManager const *)arg1)->getAudioRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_setHandleEventAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setHandleEventAction" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoSceneManager_setHandleEventAction" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->setHandleEventAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoHandleEventAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_getHandleEventAction" "', argument " "1"" of type '" "SoSceneManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  result = (SoHandleEventAction *)((SoSceneManager const *)arg1)->getHandleEventAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_getDefaultRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_getDefaultRedrawPriority", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoSceneManager::getDefaultRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_enableRealTimeUpdate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoSceneManager_enableRealTimeUpdate" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoSceneManager::enableRealTimeUpdate(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_isRealTimeUpdateEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoSceneManager_isRealTimeUpdateEnabled", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoSceneManager::isRealTimeUpdateEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRenderCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRenderCallback" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoSceneManager_setRenderCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRenderCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoSceneManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoSceneManager_setRenderCallback" "', argument " "1"" of type '" "SoSceneManager *""'"); 
  }
  arg1 = reinterpret_cast< SoSceneManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoSceneManager_setRenderCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoSceneManager_setRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoSceneManager_setRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSceneManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoSceneManager_setRenderCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoSceneManager_setRenderCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoSceneManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoSceneManager_setRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoSceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoSceneManager_setRenderCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoSceneManager_setRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoSceneManager::setRenderCallback(SoSceneManagerRenderCB *,void *const)\n"
    "    SoSceneManager::setRenderCallback(SoSceneManagerRenderCB *)\n"
    "    SoSceneManager::setRenderCallback(PyObject *,PyObject *)\n"
    "    SoSceneManager::setRenderCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoSceneManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoSceneManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoSceneManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBarrier *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbBarrier" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (SbBarrier *)new SbBarrier(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbBarrier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBarrier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBarrier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbBarrier" "', argument " "1"" of type '" "SbBarrier *""'"); 
  }
  arg1 = reinterpret_cast< SbBarrier * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbBarrier_enter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBarrier *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbBarrier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbBarrier_enter" "', argument " "1"" of type '" "SbBarrier *""'"); 
  }
  arg1 = reinterpret_cast< SbBarrier * >(argp1);
  result = (int)(arg1)->enter();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbBarrier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbBarrier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbBarrier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMutex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbMutex", 0, 0, 0)) SWIG_fail;
  result = (SbMutex *)new SbMutex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbMutex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMutex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbMutex" "', argument " "1"" of type '" "SbMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbMutex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMutex_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMutex_lock" "', argument " "1"" of type '" "SbMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbMutex * >(argp1);
  result = (int)(arg1)->lock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMutex_tryLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMutex_tryLock" "', argument " "1"" of type '" "SbMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbMutex * >(argp1);
  result = (SbBool)(arg1)->tryLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbMutex_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbMutex_unlock" "', argument " "1"" of type '" "SbMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbMutex * >(argp1);
  result = (int)(arg1)->unlock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbMutex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbMutex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbMutex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbThreadMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadMutex *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbThreadMutex", 0, 0, 0)) SWIG_fail;
  result = (SbThreadMutex *)new SbThreadMutex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbThreadMutex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbThreadMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadMutex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbThreadMutex" "', argument " "1"" of type '" "SbThreadMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadMutex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThreadMutex_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThreadMutex_lock" "', argument " "1"" of type '" "SbThreadMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadMutex * >(argp1);
  result = (int)(arg1)->lock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThreadMutex_tryLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThreadMutex_tryLock" "', argument " "1"" of type '" "SbThreadMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadMutex * >(argp1);
  result = (SbBool)(arg1)->tryLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThreadMutex_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThreadMutex_unlock" "', argument " "1"" of type '" "SbThreadMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadMutex * >(argp1);
  result = (int)(arg1)->unlock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbThreadMutex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbThreadMutex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbThreadMutex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbThreadAutoLock__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbThreadAutoLock *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbThreadAutoLock" "', argument " "1"" of type '" "SbMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbMutex * >(argp1);
  result = (SbThreadAutoLock *)new SbThreadAutoLock(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbThreadAutoLock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbThreadAutoLock__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbThreadMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbThreadAutoLock *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SbThreadAutoLock" "', argument " "1"" of type '" "SbThreadMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadMutex * >(argp1);
  result = (SbThreadAutoLock *)new SbThreadAutoLock(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbThreadAutoLock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbThreadAutoLock(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbThreadAutoLock", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbMutex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbThreadAutoLock__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbThreadMutex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SbThreadAutoLock__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbThreadAutoLock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbThreadAutoLock::SbThreadAutoLock(SbMutex *)\n"
    "    SbThreadAutoLock::SbThreadAutoLock(SbThreadMutex *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbThreadAutoLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThreadAutoLock *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThreadAutoLock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbThreadAutoLock" "', argument " "1"" of type '" "SbThreadAutoLock *""'"); 
  }
  arg1 = reinterpret_cast< SbThreadAutoLock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbThreadAutoLock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbThreadAutoLock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbThreadAutoLock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbCondVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbCondVar", 0, 0, 0)) SWIG_fail;
  result = (SbCondVar *)new SbCondVar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbCondVar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbCondVar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCondVar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbCondVar" "', argument " "1"" of type '" "SbCondVar *""'"); 
  }
  arg1 = reinterpret_cast< SbCondVar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCondVar_wait(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *arg1 = 0 ;
  SbMutex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCondVar_wait", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCondVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCondVar_wait" "', argument " "1"" of type '" "SbCondVar *""'"); 
  }
  arg1 = reinterpret_cast< SbCondVar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMutex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCondVar_wait" "', argument " "2"" of type '" "SbMutex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCondVar_wait" "', argument " "2"" of type '" "SbMutex &""'"); 
  }
  arg2 = reinterpret_cast< SbMutex * >(argp2);
  result = (SbBool)(arg1)->wait(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCondVar_timedWait(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *arg1 = 0 ;
  SbMutex *arg2 = 0 ;
  SbTime arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbCondVar_timedWait", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCondVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCondVar_timedWait" "', argument " "1"" of type '" "SbCondVar *""'"); 
  }
  arg1 = reinterpret_cast< SbCondVar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbMutex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbCondVar_timedWait" "', argument " "2"" of type '" "SbMutex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCondVar_timedWait" "', argument " "2"" of type '" "SbMutex &""'"); 
  }
  arg2 = reinterpret_cast< SbMutex * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbCondVar_timedWait" "', argument " "3"" of type '" "SbTime""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbCondVar_timedWait" "', argument " "3"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (SbBool)(arg1)->timedWait(*arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCondVar_wakeOne(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCondVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCondVar_wakeOne" "', argument " "1"" of type '" "SbCondVar *""'"); 
  }
  arg1 = reinterpret_cast< SbCondVar * >(argp1);
  (arg1)->wakeOne();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbCondVar_wakeAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbCondVar *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbCondVar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbCondVar_wakeAll" "', argument " "1"" of type '" "SbCondVar *""'"); 
  }
  arg1 = reinterpret_cast< SbCondVar * >(argp1);
  (arg1)->wakeAll();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbCondVar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbCondVar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbCondVar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbFifo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SbFifo", 0, 0, 0)) SWIG_fail;
  result = (SbFifo *)new SbFifo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbFifo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbFifo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbFifo" "', argument " "1"" of type '" "SbFifo *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_assign" "', argument " "1"" of type '" "SbFifo *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_assign" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SbFifo_assign" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_retrieve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void **arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_retrieve", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_retrieve" "', argument " "1"" of type '" "SbFifo *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_retrieve" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_retrieve" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbFifo_retrieve" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_retrieve" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  arg3 = reinterpret_cast< uint32_t * >(argp3);
  (arg1)->retrieve(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_tryRetrieve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void **arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_tryRetrieve", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_tryRetrieve" "', argument " "1"" of type '" "SbFifo *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_tryRetrieve" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_tryRetrieve" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbFifo_tryRetrieve" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_tryRetrieve" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  arg3 = reinterpret_cast< uint32_t * >(argp3);
  result = (SbBool)(arg1)->tryRetrieve(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_size" "', argument " "1"" of type '" "SbFifo const *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  result = (unsigned int)((SbFifo const *)arg1)->size();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_lock" "', argument " "1"" of type '" "SbFifo const *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  ((SbFifo const *)arg1)->lock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_unlock" "', argument " "1"" of type '" "SbFifo const *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  ((SbFifo const *)arg1)->unlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_peek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void **arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_peek", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_peek" "', argument " "1"" of type '" "SbFifo const *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_peek" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_peek" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbFifo_peek" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SbFifo_peek" "', argument " "3"" of type '" "uint32_t &""'"); 
  }
  arg3 = reinterpret_cast< uint32_t * >(argp3);
  result = (SbBool)((SbFifo const *)arg1)->peek(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_contains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_contains" "', argument " "1"" of type '" "SbFifo const *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_contains" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (SbBool)((SbFifo const *)arg1)->contains(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbFifo_reclaim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbFifo *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbFifo_reclaim", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbFifo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbFifo_reclaim" "', argument " "1"" of type '" "SbFifo *""'"); 
  }
  arg1 = reinterpret_cast< SbFifo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbFifo_reclaim" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (SbBool)(arg1)->reclaim(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbFifo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbFifo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbFifo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbRWMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex::Precedence arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SbRWMutex *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbRWMutex" "', argument " "1"" of type '" "SbRWMutex::Precedence""'");
  } 
  arg1 = static_cast< SbRWMutex::Precedence >(val1);
  result = (SbRWMutex *)new SbRWMutex(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbRWMutex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SbRWMutex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbRWMutex" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_writeLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_writeLock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (int)(arg1)->writeLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_tryWriteLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_tryWriteLock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (SbBool)(arg1)->tryWriteLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_writeUnlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_writeUnlock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (int)(arg1)->writeUnlock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_readLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_readLock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (int)(arg1)->readLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_tryReadLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_tryReadLock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (int)(arg1)->tryReadLock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbRWMutex_readUnlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbRWMutex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbRWMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbRWMutex_readUnlock" "', argument " "1"" of type '" "SbRWMutex *""'"); 
  }
  arg1 = reinterpret_cast< SbRWMutex * >(argp1);
  result = (int)(arg1)->readUnlock();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbRWMutex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbRWMutex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbRWMutex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SbStorage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SbStorage *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbStorage" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (SbStorage *)new SbStorage(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStorage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbStorage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  cc_storage_f *arg2 = 0 ;
  cc_storage_f *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbStorage *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SbStorage" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_cc_storage_f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SbStorage" "', argument " "2"" of type '" "cc_storage_f *""'"); 
  }
  arg2 = reinterpret_cast< cc_storage_f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_cc_storage_f, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SbStorage" "', argument " "3"" of type '" "cc_storage_f *""'"); 
  }
  arg3 = reinterpret_cast< cc_storage_f * >(argp3);
  result = (SbStorage *)new SbStorage(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStorage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SbStorage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SbStorage", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SbStorage__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cc_storage_f, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_cc_storage_f, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SbStorage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SbStorage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbStorage::SbStorage(unsigned int)\n"
    "    SbStorage::SbStorage(unsigned int,cc_storage_f *,cc_storage_f *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SbStorage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStorage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStorage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SbStorage" "', argument " "1"" of type '" "SbStorage *""'"); 
  }
  arg1 = reinterpret_cast< SbStorage * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStorage_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStorage *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStorage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStorage_get" "', argument " "1"" of type '" "SbStorage *""'"); 
  }
  arg1 = reinterpret_cast< SbStorage * >(argp1);
  result = (void *)(arg1)->get();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbStorage_applyToAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStorage *arg1 = 0 ;
  SbStorageApplyFunc *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbStorage_applyToAll", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbStorage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbStorage_applyToAll" "', argument " "1"" of type '" "SbStorage *""'"); 
  }
  arg1 = reinterpret_cast< SbStorage * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbStorage_applyToAll" "', argument " "2"" of type '" "SbStorageApplyFunc *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SbStorage_applyToAll" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->applyToAll(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SbStorage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbStorage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SbStorage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SbThread_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *(*arg1)(void *) = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  SbThread *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SbThread_create", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SbThread_create" "', argument " "1"" of type '" "void *(*)(void *)""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbThread_create" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (SbThread *)SbThread::create(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbThread, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThread_destroy" "', argument " "1"" of type '" "SbThread *""'"); 
  }
  arg1 = reinterpret_cast< SbThread * >(argp1);
  SbThread::destroy(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_join__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbThread *arg1 = 0 ;
  void **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThread_join" "', argument " "1"" of type '" "SbThread *""'"); 
  }
  arg1 = reinterpret_cast< SbThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbThread_join" "', argument " "2"" of type '" "void **""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  result = (SbBool)(arg1)->join(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_join__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThread_join" "', argument " "1"" of type '" "SbThread *""'"); 
  }
  arg1 = reinterpret_cast< SbThread * >(argp1);
  result = (SbBool)(arg1)->join();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_join__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbThread *arg1 = 0 ;
  void **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThread_join" "', argument " "1"" of type '" "SbThread *""'"); 
  }
  arg1 = reinterpret_cast< SbThread * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SbThread_join" "', argument " "2"" of type '" "void **""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  result = (SbBool)SbThread::join(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_join__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbThread *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SbThread, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SbThread_join" "', argument " "1"" of type '" "SbThread *""'"); 
  }
  arg1 = reinterpret_cast< SbThread * >(argp1);
  result = (SbBool)SbThread::join(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SbThread_join(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SbThread_join", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbThread_join__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SbThread_join__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_void, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbThread_join__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SbThread, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_void, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SbThread_join__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SbThread_join'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SbThread::join(void **)\n"
    "    SbThread::join()\n"
    "    SbThread::join(SbThread *,void **)\n"
    "    SbThread::join(SbThread *)\n");
  return 0;
}


SWIGINTERN PyObject *SbThread_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SbThread, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLParent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLParent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_getTypeId" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  result = ((SoVRMLParent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLParent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_children_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_children_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_children_set" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_children_set" "', argument " "2"" of type '" "SoMFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  if (arg1) (arg1)->children = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_children_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_children_get" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  result = (SoMFNode *)& ((arg1)->children);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_affectsState" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  result = (SbBool)((SoVRMLParent const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_addChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_addChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_addChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_insertChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_insertChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_insertChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLParent_insertChild" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_getChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_getChild" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLParent_getChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoVRMLParent const *)arg1)->getChild(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_findChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_findChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_findChild" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_findChild" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoVRMLParent const *)arg1)->findChild((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_getNumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_getNumChildren" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  result = (int)((SoVRMLParent const *)arg1)->getNumChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_removeChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_removeChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLParent_removeChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_removeChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_removeChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_removeChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_removeChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLParent_removeChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLParent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLParent_removeChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLParent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVRMLParent_removeChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLParent_removeChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLParent::removeChild(int)\n"
    "    SoVRMLParent::removeChild(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_removeAllChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_removeAllChildren" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  (arg1)->removeAllChildren();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_replaceChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_replaceChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLParent_replaceChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLParent_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_replaceChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_replaceChild" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_replaceChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLParent_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLParent_replaceChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLParent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLParent_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLParent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLParent_replaceChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLParent_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLParent::replaceChild(int,SoNode *)\n"
    "    SoVRMLParent::replaceChild(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_getChildren" "', argument " "1"" of type '" "SoVRMLParent const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  result = (SoChildList *)((SoVRMLParent const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_doAction" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_search" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_write" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLParent *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLParent_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLParent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLParent *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLParent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_updateChildList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode **arg1 = 0 ;
  int arg2 ;
  SoChildList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_updateChildList" "', argument " "1"" of type '" "SoNode const *const *""'"); 
  }
  arg1 = reinterpret_cast< SoNode ** >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLParent_updateChildList" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SoChildList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLParent_updateChildList" "', argument " "3"" of type '" "SoChildList &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLParent_updateChildList" "', argument " "3"" of type '" "SoChildList &""'"); 
  }
  arg3 = reinterpret_cast< SoChildList * >(argp3);
  SoVRMLParent::updateChildList((SoNode const *const *)arg1,arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_updateChildList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoNode *arg1 = 0 ;
  SoChildList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLParent_updateChildList" "', argument " "1"" of type '" "SoNode *""'"); 
  }
  arg1 = reinterpret_cast< SoNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoChildList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLParent_updateChildList" "', argument " "2"" of type '" "SoChildList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLParent_updateChildList" "', argument " "2"" of type '" "SoChildList &""'"); 
  }
  arg2 = reinterpret_cast< SoChildList * >(argp2);
  SoVRMLParent::updateChildList(arg1,*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLParent_updateChildList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLParent_updateChildList", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoChildList, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLParent_updateChildList__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_SoNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoChildList, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLParent_updateChildList__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLParent_updateChildList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLParent::updateChildList(SoNode const *const *,int const,SoChildList &)\n"
    "    SoVRMLParent::updateChildList(SoNode *,SoChildList &)\n");
  return 0;
}


SWIGINTERN PyObject *SoVRMLParent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLParent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLAnchor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAnchor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_getTypeId" "', argument " "1"" of type '" "SoVRMLAnchor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = ((SoVRMLAnchor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLAnchor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLAnchor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLAnchor *)new SoVRMLAnchor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLAnchor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_url_set" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_url_get" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_description_set" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_description_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->description = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_description_get" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = (SoSFString *)& ((arg1)->description);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_parameter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_parameter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_parameter_set" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_parameter_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->parameter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_parameter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_parameter_get" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = (SoMFString *)& ((arg1)->parameter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_bboxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_bboxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_bboxCenter_set" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_bboxCenter_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_bboxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_bboxCenter_get" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_bboxSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_bboxSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_bboxSize_set" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_bboxSize_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_bboxSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_bboxSize_get" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_setFetchURLCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_setFetchURLCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAnchor_setFetchURLCallBack" "', argument " "1"" of type '" "SoVRMLAnchorCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_setFetchURLCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoVRMLAnchor::setFetchURLCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAnchor_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAnchor *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAnchor_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAnchor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAnchor_handleEvent" "', argument " "1"" of type '" "SoVRMLAnchor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAnchor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAnchor_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLAnchor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLAnchor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLAnchor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLAppearance_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAppearance::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_getTypeId" "', argument " "1"" of type '" "SoVRMLAppearance const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  result = ((SoVRMLAppearance const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLAppearance::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLAppearance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLAppearance", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLAppearance *)new SoVRMLAppearance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLAppearance, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_material_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_material_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_material_set" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_material_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->material = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_material_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_material_get" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  result = (SoSFNode *)& ((arg1)->material);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_texture_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_texture_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_texture_set" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_texture_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->texture = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_texture_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_texture_get" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  result = (SoSFNode *)& ((arg1)->texture);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_textureTransform_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_textureTransform_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_textureTransform_set" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_textureTransform_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->textureTransform = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_textureTransform_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_textureTransform_get" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  result = (SoSFNode *)& ((arg1)->textureTransform);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_doAction" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_callback" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_GLRender" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_search" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_getChildren" "', argument " "1"" of type '" "SoVRMLAppearance const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  result = (SoChildList *)((SoVRMLAppearance const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_notify" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAppearance_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAppearance *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAppearance_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAppearance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAppearance_copyContents" "', argument " "1"" of type '" "SoVRMLAppearance *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAppearance * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAppearance_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLAppearance_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLAppearance_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLAppearance, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLAppearance_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAudioClip::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_getTypeId" "', argument " "1"" of type '" "SoVRMLAudioClip const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = ((SoVRMLAudioClip const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLAudioClip::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLAudioClip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLAudioClip", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLAudioClip *)new SoVRMLAudioClip();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLAudioClip, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_description_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_description_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->description = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_description_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoSFString *)& ((arg1)->description);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_loop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_loop_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_loop_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_loop_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->loop = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_loop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_loop_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoSFBool *)& ((arg1)->loop);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_pitch_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_pitch_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_pitch_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_pitch_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->pitch = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_pitch_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_pitch_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoSFFloat *)& ((arg1)->pitch);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_startTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_startTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_startTime_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_startTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->startTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_startTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_startTime_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoSFTime *)& ((arg1)->startTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_stopTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_stopTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_stopTime_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_stopTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->stopTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_stopTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_stopTime_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoSFTime *)& ((arg1)->stopTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_url_set" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_url_get" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setSubdirectories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbList< SbString > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbListT_SbString_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_setSubdirectories" "', argument " "1"" of type '" "SbList< SbString > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_setSubdirectories" "', argument " "1"" of type '" "SbList< SbString > const &""'"); 
  }
  arg1 = reinterpret_cast< SbList< SbString > * >(argp1);
  SoVRMLAudioClip::setSubdirectories((SbList< SbString > const &)*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getSubdirectories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbStringList *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getSubdirectories", 0, 0, 0)) SWIG_fail;
  result = (SbStringList *) &SoVRMLAudioClip::getSubdirectories();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbStringList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setDefaultPauseBetweenTracks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_setDefaultPauseBetweenTracks" "', argument " "1"" of type '" "SbTime""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_setDefaultPauseBetweenTracks" "', argument " "1"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  SoVRMLAudioClip::setDefaultPauseBetweenTracks(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getDefaultPauseBetweenTracks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getDefaultPauseBetweenTracks", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAudioClip::getDefaultPauseBetweenTracks();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setDefaultIntroPause(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_setDefaultIntroPause" "', argument " "1"" of type '" "SbTime""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_setDefaultIntroPause" "', argument " "1"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  SoVRMLAudioClip::setDefaultIntroPause(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getDefaultIntroPause(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getDefaultIntroPause", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAudioClip::getDefaultIntroPause();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setDefaultSampleRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLAudioClip_setDefaultSampleRate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SoVRMLAudioClip::setDefaultSampleRate(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getDefaultSampleRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getDefaultSampleRate", 0, 0, 0)) SWIG_fail;
  result = (int)SoVRMLAudioClip::getDefaultSampleRate();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setDefaultTimerInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_setDefaultTimerInterval" "', argument " "1"" of type '" "SbTime""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_setDefaultTimerInterval" "', argument " "1"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  SoVRMLAudioClip::setDefaultTimerInterval(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getDefaultTimerInterval(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbTime result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_getDefaultTimerInterval", 0, 0, 0)) SWIG_fail;
  result = SoVRMLAudioClip::getDefaultTimerInterval();
  resultobj = SWIG_NewPointerObj((new SbTime(result)), SWIGTYPE_p_SbTime, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_getSampleRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_getSampleRate" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  result = (int)(arg1)->getSampleRate();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_open(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SbStringList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_open", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_open" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbStringList,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_open" "', argument " "2"" of type '" "SbStringList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_open" "', argument " "2"" of type '" "SbStringList const &""'"); 
  }
  arg2 = reinterpret_cast< SbStringList * >(argp2);
  result = (void *)(arg1)->open((SbStringList const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *arg2 = 0 ;
  void *arg3 = 0 ;
  int arg4 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_read", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_read" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_read" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLAudioClip_read" "', argument " "3"" of type '" "void *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVRMLAudioClip_read" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoVRMLAudioClip_read" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLAudioClip_read" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  result = (arg1)->read(arg2,arg3,arg4,*arg5);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_seek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *arg2 = 0 ;
  long arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_seek", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_seek" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_seek" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLAudioClip_seek" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoVRMLAudioClip_seek" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)(arg1)->seek(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_tell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_tell", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_tell" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_tell" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (long)(arg1)->tell(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  void *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_close", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_close" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLAudioClip_close" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (int)(arg1)->close(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLAudioClip_setCallbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLAudioClip *arg1 = 0 ;
  SoVRMLAudioClip::open_func *arg2 = 0 ;
  SoVRMLAudioClip::read_func *arg3 = 0 ;
  SoVRMLAudioClip::seek_func *arg4 = 0 ;
  SoVRMLAudioClip::tell_func *arg5 = 0 ;
  SoVRMLAudioClip::close_func *arg6 = 0 ;
  void *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res7 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLAudioClip_setCallbacks", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLAudioClip, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "1"" of type '" "SoVRMLAudioClip *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLAudioClip * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "2"" of type '" "SoVRMLAudioClip::open_func *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "3"" of type '" "SoVRMLAudioClip::read_func *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "4"" of type '" "SoVRMLAudioClip::seek_func *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__long);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "5"" of type '" "SoVRMLAudioClip::tell_func *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[5], (void**)(&arg6), SWIGTYPE_p_f_p_void_p_SoVRMLAudioClip_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "6"" of type '" "SoVRMLAudioClip::close_func *""'"); 
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6],SWIG_as_voidptrptr(&arg7), 0, 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SoVRMLAudioClip_setCallbacks" "', argument " "7"" of type '" "void *""'"); 
  }
  (arg1)->setCallbacks(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLAudioClip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLAudioClip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLAudioClip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLBackground_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLBackground::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_getTypeId" "', argument " "1"" of type '" "SoVRMLBackground const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = ((SoVRMLBackground const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLBackground::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLBackground(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLBackground", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLBackground *)new SoVRMLBackground();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLBackground, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_groundColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_groundColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_groundColor_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_groundColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->groundColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_groundColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_groundColor_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFColor *)& ((arg1)->groundColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_groundAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_groundAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_groundAngle_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_groundAngle_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->groundAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_groundAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_groundAngle_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFFloat *)& ((arg1)->groundAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_skyColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_skyColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_skyColor_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_skyColor_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->skyColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_skyColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_skyColor_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFColor *)& ((arg1)->skyColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_skyAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_skyAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_skyAngle_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_skyAngle_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->skyAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_skyAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_skyAngle_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFFloat *)& ((arg1)->skyAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_backUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_backUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_backUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_backUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->backUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_backUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_backUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->backUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_bottomUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_bottomUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_bottomUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_bottomUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->bottomUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_bottomUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_bottomUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->bottomUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_frontUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_frontUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_frontUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_frontUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->frontUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_frontUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_frontUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->frontUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_leftUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_leftUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_leftUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_leftUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->leftUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_leftUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_leftUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->leftUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_rightUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_rightUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_rightUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_rightUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->rightUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_rightUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_rightUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->rightUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_topUrl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_topUrl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_topUrl_set" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_topUrl_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->topUrl = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_topUrl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_topUrl_get" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  result = (SoMFString *)& ((arg1)->topUrl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBackground_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBackground *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBackground_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBackground, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBackground_GLRender" "', argument " "1"" of type '" "SoVRMLBackground *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBackground * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBackground_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLBackground_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLBackground, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLBackground_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLBillboard_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLBillboard::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_getTypeId" "', argument " "1"" of type '" "SoVRMLBillboard const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  result = ((SoVRMLBillboard const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLBillboard::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLBillboard__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLBillboard *)new SoVRMLBillboard();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLBillboard, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLBillboard__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLBillboard *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLBillboard" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLBillboard *)new SoVRMLBillboard(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLBillboard, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLBillboard(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLBillboard", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLBillboard__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLBillboard__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLBillboard'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLBillboard::SoVRMLBillboard()\n"
    "    SoVRMLBillboard::SoVRMLBillboard(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_axisOfRotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_axisOfRotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_axisOfRotation_set" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_axisOfRotation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->axisOfRotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_axisOfRotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_axisOfRotation_get" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->axisOfRotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_bboxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_bboxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_bboxCenter_set" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_bboxCenter_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_bboxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_bboxCenter_get" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_bboxSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_bboxSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_bboxSize_set" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_bboxSize_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_bboxSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_bboxSize_get" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_doAction" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_callback" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_GLRender" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_getBoundingBox" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_getMatrix" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_pick" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_search" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_GLRenderBelowPath" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_GLRenderInPath" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_GLRenderOffPath" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBillboard_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBillboard *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBillboard_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBillboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBillboard_notify" "', argument " "1"" of type '" "SoVRMLBillboard *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBillboard * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBillboard_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLBillboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLBillboard, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLBillboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLGeometry_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGeometry_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLGeometry::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGeometry_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGeometry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGeometry_getTypeId" "', argument " "1"" of type '" "SoVRMLGeometry const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGeometry * >(argp1);
  result = ((SoVRMLGeometry const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGeometry_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGeometry_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLGeometry::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGeometry_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGeometry *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGeometry_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGeometry_search" "', argument " "1"" of type '" "SoVRMLGeometry *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGeometry_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGeometry_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGeometry *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGeometry_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGeometry_copyContents" "', argument " "1"" of type '" "SoVRMLGeometry *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGeometry_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLGeometry_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLGeometry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLBox_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLBox::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_getTypeId" "', argument " "1"" of type '" "SoVRMLBox const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  result = ((SoVRMLBox const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLBox::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLBox", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLBox *)new SoVRMLBox();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLBox, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_size_set" "', argument " "1"" of type '" "SoVRMLBox *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBox_size_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_size_get" "', argument " "1"" of type '" "SoVRMLBox *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_GLRender" "', argument " "1"" of type '" "SoVRMLBox *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBox_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_rayPick" "', argument " "1"" of type '" "SoVRMLBox *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBox_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLBox_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLBox *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLBox_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLBox_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLBox *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLBox * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLBox_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLBox, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLGroup_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLGroup::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_getTypeId" "', argument " "1"" of type '" "SoVRMLGroup const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = ((SoVRMLGroup const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLGroup::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLGroup *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLGroup *)new SoVRMLGroup();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLGroup, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLGroup *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLGroup" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLGroup *)new SoVRMLGroup(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLGroup, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLGroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLGroup", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLGroup__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLGroup__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLGroup::SoVRMLGroup()\n"
    "    SoVRMLGroup::SoVRMLGroup(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_renderCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_renderCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_renderCaching_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_renderCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_renderCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_renderCaching_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_boundingBoxCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_boundingBoxCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_boundingBoxCaching_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_boundingBoxCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->boundingBoxCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_boundingBoxCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_boundingBoxCaching_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFEnum *)& ((arg1)->boundingBoxCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_renderCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_renderCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_renderCulling_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_renderCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_renderCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_renderCulling_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_pickCulling_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_pickCulling_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_pickCulling_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_pickCulling_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->pickCulling = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_pickCulling_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_pickCulling_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFEnum *)& ((arg1)->pickCulling);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_bboxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_bboxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_bboxCenter_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_bboxCenter_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_bboxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_bboxCenter_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_bboxSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_bboxSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_bboxSize_set" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_bboxSize_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_bboxSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_bboxSize_get" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_setNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLGroup_setNumRenderCaches" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SoVRMLGroup::setNumRenderCaches(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_getNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_getNumRenderCaches", 0, 0, 0)) SWIG_fail;
  result = (int)SoVRMLGroup::getNumRenderCaches();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_doAction" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_callback" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_GLRender" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_getBoundingBox" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_getMatrix" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_rayPick" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_search" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_write" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_audioRender" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_GLRenderBelowPath" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_GLRenderInPath" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_GLRenderOffPath" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLGroup_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLGroup *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLGroup_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLGroup_notify" "', argument " "1"" of type '" "SoVRMLGroup *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLGroup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLGroup_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLGroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLGroup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLGroup_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLCollision_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCollision::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_getTypeId" "', argument " "1"" of type '" "SoVRMLCollision const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  result = ((SoVRMLCollision const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCollision::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCollision__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLCollision *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLCollision *)new SoVRMLCollision();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCollision, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCollision__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLCollision *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLCollision" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLCollision *)new SoVRMLCollision(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCollision, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCollision(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLCollision", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLCollision__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLCollision__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLCollision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLCollision::SoVRMLCollision()\n"
    "    SoVRMLCollision::SoVRMLCollision(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_collide_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_collide_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_collide_set" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCollision_collide_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->collide = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_collide_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_collide_get" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  result = (SoSFBool *)& ((arg1)->collide);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_proxy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_proxy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_proxy_set" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCollision_proxy_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->proxy = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_proxy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_proxy_get" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  result = (SoSFNode *)& ((arg1)->proxy);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_collideTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_collideTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_collideTime_set" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCollision_collideTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->collideTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_collideTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_collideTime_get" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  result = (SoSFTime *)& ((arg1)->collideTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_GLRender" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCollision_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCollision_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCollision *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCollision_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCollision_notify" "', argument " "1"" of type '" "SoVRMLCollision *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCollision * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCollision_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCollision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCollision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCollision_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLColor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLColor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_getTypeId" "', argument " "1"" of type '" "SoVRMLColor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  result = ((SoVRMLColor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLColor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLColor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLColor *)new SoVRMLColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLColor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_color_set" "', argument " "1"" of type '" "SoVRMLColor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColor_color_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_color_get" "', argument " "1"" of type '" "SoVRMLColor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  result = (SoMFColor *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_doAction" "', argument " "1"" of type '" "SoVRMLColor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColor_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_GLRender" "', argument " "1"" of type '" "SoVRMLColor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColor_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColor_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColor *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColor_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColor_callback" "', argument " "1"" of type '" "SoVRMLColor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColor_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLColor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLColor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLColor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  result = ((SoVRMLInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_key_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInterpolator_key_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_key_set" "', argument " "1"" of type '" "SoVRMLInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInterpolator_key_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->key = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_key_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_key_get" "', argument " "1"" of type '" "SoVRMLInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->key);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_set_fraction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInterpolator_set_fraction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_set_fraction_set" "', argument " "1"" of type '" "SoVRMLInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInterpolator_set_fraction_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->set_fraction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_set_fraction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInterpolator_set_fraction_get" "', argument " "1"" of type '" "SoVRMLInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInterpolator * >(argp1);
  result = (SoSFFloat *)& ((arg1)->set_fraction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColorInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLColorInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLColorInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  result = ((SoVRMLColorInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLColorInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLColorInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColorInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLColorInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColorInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLColorInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLColorInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLColorInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLColorInterpolator *)new SoVRMLColorInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLColorInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  SoMFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColorInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLColorInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColorInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoMFColor * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLColorInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  result = (SoMFColor *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLColorInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLColorInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLColorInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLColorInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLColorInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLColorInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLColorInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLColorInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLColorInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLColorInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLColorInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLColorInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLCone_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCone::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_getTypeId" "', argument " "1"" of type '" "SoVRMLCone const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  result = ((SoVRMLCone const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCone::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLCone", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLCone *)new SoVRMLCone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCone, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_bottomRadius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_bottomRadius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_bottomRadius_set" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_bottomRadius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->bottomRadius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_bottomRadius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_bottomRadius_get" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  result = (SoSFFloat *)& ((arg1)->bottomRadius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_height_set" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_height_get" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_side_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_side_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_side_set" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_side_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->side = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_side_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_side_get" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  result = (SoSFBool *)& ((arg1)->side);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_bottom_set" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_bottom_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->bottom = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_bottom_get" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  result = (SoSFBool *)& ((arg1)->bottom);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_GLRender" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_rayPick" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCone_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCone *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCone_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCone_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLCone *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCone * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCone_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCone_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCone, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCone_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCoordinate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_getTypeId" "', argument " "1"" of type '" "SoVRMLCoordinate const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  result = ((SoVRMLCoordinate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCoordinate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCoordinate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLCoordinate", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLCoordinate *)new SoVRMLCoordinate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCoordinate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_point_set" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_point_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_point_get" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_doAction" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_GLRender" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_getBoundingBox" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_callback" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinate_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinate *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinate_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinate_pick" "', argument " "1"" of type '" "SoVRMLCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinate_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCoordinate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCoordinate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCoordinate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinateInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCoordinateInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  result = ((SoVRMLCoordinateInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLCoordinateInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinateInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLCoordinateInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinateInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCoordinateInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCoordinateInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLCoordinateInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLCoordinateInterpolator *)new SoVRMLCoordinateInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCoordinateInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinateInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinateInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCoordinateInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCoordinateInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCoordinateInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCoordinateInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCoordinateInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCoordinateInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLCoordinateInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCoordinateInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCoordinateInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCoordinateInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCoordinateInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLCylinder_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCylinder::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_getTypeId" "', argument " "1"" of type '" "SoVRMLCylinder const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = ((SoVRMLCylinder const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCylinder::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCylinder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLCylinder", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLCylinder *)new SoVRMLCylinder();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCylinder, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_radius_set" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_radius_get" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_height_set" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_height_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_height_get" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = (SoSFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_side_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_side_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_side_set" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_side_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->side = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_side_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_side_get" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = (SoSFBool *)& ((arg1)->side);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_top_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_top_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_top_set" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_top_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->top = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_top_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_top_get" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = (SoSFBool *)& ((arg1)->top);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_bottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_bottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_bottom_set" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_bottom_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->bottom = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_bottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_bottom_get" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  result = (SoSFBool *)& ((arg1)->bottom);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_GLRender" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_rayPick" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinder_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinder *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinder_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinder_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLCylinder *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinder * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinder_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCylinder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCylinder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSensor * >(argp1);
  result = ((SoVRMLSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSensor_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSensor_isActive_set" "', argument " "1"" of type '" "SoVRMLSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSensor_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSensor_isActive_get" "', argument " "1"" of type '" "SoVRMLSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSensor_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSensor_enabled_set" "', argument " "1"" of type '" "SoVRMLSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSensor_enabled_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enabled = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSensor_enabled_get" "', argument " "1"" of type '" "SoVRMLSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->enabled);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDragSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLDragSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLDragSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  result = ((SoVRMLDragSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_trackPoint_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDragSensor_trackPoint_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_trackPoint_changed_set" "', argument " "1"" of type '" "SoVRMLDragSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLDragSensor_trackPoint_changed_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->trackPoint_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_trackPoint_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_trackPoint_changed_get" "', argument " "1"" of type '" "SoVRMLDragSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->trackPoint_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_autoOffset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDragSensor_autoOffset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_autoOffset_set" "', argument " "1"" of type '" "SoVRMLDragSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLDragSensor_autoOffset_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->autoOffset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_autoOffset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_autoOffset_get" "', argument " "1"" of type '" "SoVRMLDragSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->autoOffset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDragSensor *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDragSensor_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDragSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDragSensor_handleEvent" "', argument " "1"" of type '" "SoVRMLDragSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDragSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLDragSensor_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDragSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDragSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLDragSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLDragSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLDragSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLCylinderSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLCylinderSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = ((SoVRMLCylinderSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLCylinderSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLCylinderSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLCylinderSensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLCylinderSensor *)new SoVRMLCylinderSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLCylinderSensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_diskAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_diskAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_diskAngle_set" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinderSensor_diskAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->diskAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_diskAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_diskAngle_get" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = (SoSFFloat *)& ((arg1)->diskAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_maxAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_maxAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_maxAngle_set" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinderSensor_maxAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->maxAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_maxAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_maxAngle_get" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = (SoSFFloat *)& ((arg1)->maxAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_minAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_minAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_minAngle_set" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinderSensor_minAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->minAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_minAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_minAngle_get" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = (SoSFFloat *)& ((arg1)->minAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_offset_set" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinderSensor_offset_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_offset_get" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = (SoSFFloat *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_rotation_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLCylinderSensor_rotation_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_rotation_changed_set" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLCylinderSensor_rotation_changed_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLCylinderSensor_rotation_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLCylinderSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLCylinderSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLCylinderSensor_rotation_changed_get" "', argument " "1"" of type '" "SoVRMLCylinderSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLCylinderSensor * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLCylinderSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLCylinderSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLCylinderSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_getTypeId" "', argument " "1"" of type '" "SoVRMLLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  result = ((SoVRMLLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_on_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_on_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_on_set" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLight_on_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->on = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_on_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_on_get" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  result = (SoSFBool *)& ((arg1)->on);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_intensity_set" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLight_intensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->intensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_intensity_get" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->intensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_color_set" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLight_color_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_color_get" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  result = (SoSFColor *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_ambientIntensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_ambientIntensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_ambientIntensity_set" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLight_ambientIntensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->ambientIntensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_ambientIntensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_ambientIntensity_get" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->ambientIntensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLight_GLRender" "', argument " "1"" of type '" "SoVRMLLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDirectionalLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLDirectionalLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDirectionalLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDirectionalLight_getTypeId" "', argument " "1"" of type '" "SoVRMLDirectionalLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDirectionalLight * >(argp1);
  result = ((SoVRMLDirectionalLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDirectionalLight_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLDirectionalLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLDirectionalLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDirectionalLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLDirectionalLight", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLDirectionalLight *)new SoVRMLDirectionalLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLDirectionalLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDirectionalLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDirectionalLight_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDirectionalLight_direction_set" "', argument " "1"" of type '" "SoVRMLDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDirectionalLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLDirectionalLight_direction_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDirectionalLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDirectionalLight_direction_get" "', argument " "1"" of type '" "SoVRMLDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDirectionalLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLDirectionalLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLDirectionalLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLDirectionalLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLDirectionalLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLDirectionalLight_GLRender" "', argument " "1"" of type '" "SoVRMLDirectionalLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLDirectionalLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLDirectionalLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLDirectionalLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLDirectionalLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLDirectionalLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLElevationGrid::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_getTypeId" "', argument " "1"" of type '" "SoVRMLElevationGrid const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = ((SoVRMLElevationGrid const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLElevationGrid::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLElevationGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLElevationGrid", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLElevationGrid *)new SoVRMLElevationGrid();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLElevationGrid, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_ccw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_ccw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_ccw_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_ccw_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->ccw = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_ccw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_ccw_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFBool *)& ((arg1)->ccw);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_solid_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_solid_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->solid = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_solid_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFBool *)& ((arg1)->solid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_creaseAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_creaseAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_creaseAngle_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_creaseAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->creaseAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_creaseAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_creaseAngle_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFFloat *)& ((arg1)->creaseAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_zDimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_zDimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_zDimension_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_zDimension_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->zDimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_zDimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_zDimension_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->zDimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_xDimension_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_xDimension_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_xDimension_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_xDimension_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->xDimension = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_xDimension_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_xDimension_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->xDimension);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_zSpacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_zSpacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_zSpacing_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_zSpacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->zSpacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_zSpacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_zSpacing_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFFloat *)& ((arg1)->zSpacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_xSpacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_xSpacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_xSpacing_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_xSpacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->xSpacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_xSpacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_xSpacing_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFFloat *)& ((arg1)->xSpacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_height_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_height_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_height_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_height_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->height = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_height_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_height_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoMFFloat *)& ((arg1)->height);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_texCoord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_texCoord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_texCoord_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_texCoord_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->texCoord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_texCoord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_texCoord_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFNode *)& ((arg1)->texCoord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_normal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_normal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_normal_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_normal_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->normal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_normal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_normal_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFNode *)& ((arg1)->normal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_color_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_color_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_color_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFNode *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_colorPerVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_colorPerVertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_colorPerVertex_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_colorPerVertex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->colorPerVertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_colorPerVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_colorPerVertex_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFBool *)& ((arg1)->colorPerVertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_normalPerVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_normalPerVertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_normalPerVertex_set" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_normalPerVertex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->normalPerVertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_normalPerVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_normalPerVertex_get" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  result = (SoSFBool *)& ((arg1)->normalPerVertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_GLRender" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_rayPick" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLElevationGrid_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLElevationGrid *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLElevationGrid_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLElevationGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLElevationGrid_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLElevationGrid *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLElevationGrid * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLElevationGrid_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLElevationGrid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLElevationGrid, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLElevationGrid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLExtrusion::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_getTypeId" "', argument " "1"" of type '" "SoVRMLExtrusion const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = ((SoVRMLExtrusion const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLExtrusion::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLExtrusion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLExtrusion", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLExtrusion *)new SoVRMLExtrusion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLExtrusion, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_beginCap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_beginCap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_beginCap_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_beginCap_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->beginCap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_beginCap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_beginCap_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFBool *)& ((arg1)->beginCap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_ccw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_ccw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_ccw_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_ccw_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->ccw = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_ccw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_ccw_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFBool *)& ((arg1)->ccw);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_convex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_convex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_convex_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_convex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->convex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_convex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_convex_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFBool *)& ((arg1)->convex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_creaseAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_creaseAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_creaseAngle_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_creaseAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->creaseAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_creaseAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_creaseAngle_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFFloat *)& ((arg1)->creaseAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_crossSection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_crossSection_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_crossSection_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_crossSection_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->crossSection = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_crossSection_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_crossSection_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->crossSection);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_endCap_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_endCap_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_endCap_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_endCap_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->endCap = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_endCap_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_endCap_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFBool *)& ((arg1)->endCap);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_orientation_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_orientation_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_orientation_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoMFRotation *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_scale_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_scale_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_scale_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_solid_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_solid_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->solid = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_solid_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoSFBool *)& ((arg1)->solid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_spine_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_spine_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_spine_set" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_spine_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->spine = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_spine_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_spine_get" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->spine);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_GLRender" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLExtrusion_computeBBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLExtrusion *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  SbBox3f *arg3 = 0 ;
  SbVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLExtrusion_computeBBox", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLExtrusion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "1"" of type '" "SoVRMLExtrusion *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLExtrusion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbBox3f,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "3"" of type '" "SbBox3f &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "3"" of type '" "SbBox3f &""'"); 
  }
  arg3 = reinterpret_cast< SbBox3f * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec3f,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLExtrusion_computeBBox" "', argument " "4"" of type '" "SbVec3f &""'"); 
  }
  arg4 = reinterpret_cast< SbVec3f * >(argp4);
  (arg1)->computeBBox(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLExtrusion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLExtrusion, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLExtrusion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLFog_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLFog::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_getTypeId" "', argument " "1"" of type '" "SoVRMLFog const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  result = ((SoVRMLFog const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLFog::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLFog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLFog", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLFog *)new SoVRMLFog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLFog, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_fogType_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_fogType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_fogType_set" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFog_fogType_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->fogType = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_fogType_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_fogType_get" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  result = (SoSFString *)& ((arg1)->fogType);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_visibilityRange_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_visibilityRange_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_visibilityRange_set" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFog_visibilityRange_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->visibilityRange = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_visibilityRange_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_visibilityRange_get" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  result = (SoSFFloat *)& ((arg1)->visibilityRange);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_color_set" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFog_color_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_color_get" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  result = (SoSFColor *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFog_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFog *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFog_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFog_GLRender" "', argument " "1"" of type '" "SoVRMLFog *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFog_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLFog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLFog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLFog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLFontStyle::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_getTypeId" "', argument " "1"" of type '" "SoVRMLFontStyle const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = ((SoVRMLFontStyle const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLFontStyle::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLFontStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLFontStyle", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLFontStyle *)new SoVRMLFontStyle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLFontStyle, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_size_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_size_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_size_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFFloat *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_family_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_family_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_family_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_family_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->family = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_family_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_family_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoMFString *)& ((arg1)->family);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_style_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_style_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_style_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_style_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->style = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_style_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_style_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoMFString *)& ((arg1)->style);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_horizontal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_horizontal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_horizontal_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_horizontal_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->horizontal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_horizontal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_horizontal_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFBool *)& ((arg1)->horizontal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_leftToRight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_leftToRight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_leftToRight_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_leftToRight_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->leftToRight = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_leftToRight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_leftToRight_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFBool *)& ((arg1)->leftToRight);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_topToBottom_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_topToBottom_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_topToBottom_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_topToBottom_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->topToBottom = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_topToBottom_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_topToBottom_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFBool *)& ((arg1)->topToBottom);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_language_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_language_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_language_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_language_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->language = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_language_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_language_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFString *)& ((arg1)->language);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_justify_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_justify_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_justify_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_justify_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->justify = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_justify_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_justify_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoMFString *)& ((arg1)->justify);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_spacing_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_spacing_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_spacing_set" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_spacing_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->spacing = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_spacing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_spacing_get" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (SoSFFloat *)& ((arg1)->spacing);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_getFontName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_getFontName" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  result = (arg1)->getFontName();
  resultobj = SWIG_NewPointerObj((new SbString(result)), SWIGTYPE_p_SbString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_doAction" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_callback" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_GLRender" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_getBoundingBox" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_pick" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLFontStyle_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLFontStyle *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLFontStyle_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLFontStyle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLFontStyle_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLFontStyle *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLFontStyle * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLFontStyle_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLFontStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLFontStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLFontStyle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_so_vrml_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "so_vrml_init", 0, 0, 0)) SWIG_fail;
  so_vrml_init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTexture_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTexture::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_getTypeId" "', argument " "1"" of type '" "SoVRMLTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  result = ((SoVRMLTexture const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTexture_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTexture::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_repeatS_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTexture_repeatS_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_repeatS_set" "', argument " "1"" of type '" "SoVRMLTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTexture_repeatS_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->repeatS = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_repeatS_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_repeatS_get" "', argument " "1"" of type '" "SoVRMLTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  result = (SoSFBool *)& ((arg1)->repeatS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_repeatT_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTexture_repeatT_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_repeatT_set" "', argument " "1"" of type '" "SoVRMLTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTexture_repeatT_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->repeatT = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_repeatT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_repeatT_get" "', argument " "1"" of type '" "SoVRMLTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  result = (SoSFBool *)& ((arg1)->repeatT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTexture_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTexture *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTexture_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTexture_GLRender" "', argument " "1"" of type '" "SoVRMLTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTexture_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLImageTexture::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_getTypeId" "', argument " "1"" of type '" "SoVRMLImageTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  result = ((SoVRMLImageTexture const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLImageTexture::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLImageTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLImageTexture", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLImageTexture *)new SoVRMLImageTexture();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLImageTexture, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_url_set" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_url_get" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_setDelayFetchURL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLImageTexture_setDelayFetchURL" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoVRMLImageTexture::setDelayFetchURL(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_setPrequalifyFileCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VRMLPrequalifyFileCallback *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_setPrequalifyFileCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLImageTexture_setPrequalifyFileCallBack" "', argument " "1"" of type '" "VRMLPrequalifyFileCallback *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_setPrequalifyFileCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoVRMLImageTexture::setPrequalifyFileCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_allowPrequalifyFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_allowPrequalifyFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_allowPrequalifyFile" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLImageTexture_allowPrequalifyFile" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->allowPrequalifyFile(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_doAction" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_GLRender" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_callback" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_rayPick" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_setImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  SbImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLImageTexture_setImage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_setImage" "', argument " "1"" of type '" "SoVRMLImageTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbImage,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLImageTexture_setImage" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLImageTexture_setImage" "', argument " "2"" of type '" "SbImage const &""'"); 
  }
  arg2 = reinterpret_cast< SbImage * >(argp2);
  (arg1)->setImage((SbImage const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_getImage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLImageTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLImageTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLImageTexture_getImage" "', argument " "1"" of type '" "SoVRMLImageTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLImageTexture * >(argp1);
  result = (SbImage *)((SoVRMLImageTexture const *)arg1)->getImage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLImageTexture_setImageDataMaxAge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLImageTexture_setImageDataMaxAge" "', argument " "1"" of type '" "uint32_t""'");
  } 
  arg1 = static_cast< uint32_t >(val1);
  SoVRMLImageTexture::setImageDataMaxAge(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLImageTexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLImageTexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLImageTexture_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLVertexShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_getTypeId" "', argument " "1"" of type '" "SoVRMLVertexShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = ((SoVRMLVertexShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLVertexShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_coord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_coord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_coord_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_coord_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->coord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_coord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_coord_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->coord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_texCoord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_texCoord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_texCoord_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_texCoord_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->texCoord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_texCoord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_texCoord_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->texCoord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_normal_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_normal_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_normal_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_normal_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->normal = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_normal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_normal_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->normal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_color_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_color_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_color_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_colorPerVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_colorPerVertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_colorPerVertex_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_colorPerVertex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->colorPerVertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_colorPerVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_colorPerVertex_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFBool *)& ((arg1)->colorPerVertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_normalPerVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_normalPerVertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_normalPerVertex_set" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_normalPerVertex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->normalPerVertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_normalPerVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_normalPerVertex_get" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  result = (SoSFBool *)& ((arg1)->normalPerVertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_generateDefaultNormals__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_generateDefaultNormals__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalCache *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLVertexShape_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalCache *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalCache * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_generateDefaultNormals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_generateDefaultNormals", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLVertexShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalBundle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLVertexShape_generateDefaultNormals__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLVertexShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalCache, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLVertexShape_generateDefaultNormals__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLVertexShape_generateDefaultNormals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLVertexShape::generateDefaultNormals(SoState *,SoNormalBundle *)\n"
    "    SoVRMLVertexShape::generateDefaultNormals(SoState *,SoNormalCache *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_doAction" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_GLRender" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_getBoundingBox" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_callback" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_pick" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexShape_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexShape *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexShape_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexShape_notify" "', argument " "1"" of type '" "SoVRMLVertexShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexShape_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLVertexShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLVertexShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLIndexedShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_getTypeId" "', argument " "1"" of type '" "SoVRMLIndexedShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  result = ((SoVRMLIndexedShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLIndexedShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_coordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_coordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_coordIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedShape_coordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->coordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_coordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_coordIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->coordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_colorIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_colorIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_colorIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedShape_colorIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->colorIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_colorIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_colorIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->colorIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_normalIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_normalIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_normalIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedShape_normalIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->normalIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_normalIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_normalIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->normalIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_texCoordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedShape_texCoordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_texCoordIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedShape_texCoordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->texCoordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedShape_texCoordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedShape_texCoordIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedShape * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->texCoordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLIndexedShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLIndexedShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLIndexedFaceSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_getTypeId" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  result = ((SoVRMLIndexedFaceSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLIndexedFaceSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLIndexedFaceSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLIndexedFaceSet", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLIndexedFaceSet *)new SoVRMLIndexedFaceSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLIndexedFaceSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_ccw_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_ccw_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_ccw_set" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_ccw_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->ccw = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_ccw_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_ccw_get" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  result = (SoSFBool *)& ((arg1)->ccw);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_solid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_solid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_solid_set" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_solid_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->solid = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_solid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_solid_get" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  result = (SoSFBool *)& ((arg1)->solid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_convex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_convex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_convex_set" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_convex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->convex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_convex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_convex_get" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  result = (SoSFBool *)& ((arg1)->convex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_creaseAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_creaseAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_creaseAngle_set" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_creaseAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->creaseAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_creaseAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_creaseAngle_get" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  result = (SoSFFloat *)& ((arg1)->creaseAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_GLRender" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_generateDefaultNormals__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalBundle *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalBundle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalBundle *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalBundle * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_generateDefaultNormals__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLIndexedFaceSet *arg1 = 0 ;
  SoState *arg2 = 0 ;
  SoNormalCache *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SbBool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedFaceSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "1"" of type '" "SoVRMLIndexedFaceSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedFaceSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "2"" of type '" "SoState *""'"); 
  }
  arg2 = reinterpret_cast< SoState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNormalCache, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLIndexedFaceSet_generateDefaultNormals" "', argument " "3"" of type '" "SoNormalCache *""'"); 
  }
  arg3 = reinterpret_cast< SoNormalCache * >(argp3);
  result = (SbBool)(arg1)->generateDefaultNormals(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedFaceSet_generateDefaultNormals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLIndexedFaceSet_generateDefaultNormals", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLIndexedFaceSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalBundle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLIndexedFaceSet_generateDefaultNormals__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLIndexedFaceSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNormalCache, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLIndexedFaceSet_generateDefaultNormals__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLIndexedFaceSet_generateDefaultNormals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLIndexedFaceSet::generateDefaultNormals(SoState *,SoNormalBundle *)\n"
    "    SoVRMLIndexedFaceSet::generateDefaultNormals(SoState *,SoNormalCache *)\n");
  return 0;
}


SWIGINTERN PyObject *SoVRMLIndexedFaceSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLIndexedFaceSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLIndexedFaceSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLVertexLine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_getTypeId" "', argument " "1"" of type '" "SoVRMLVertexLine const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  result = ((SoVRMLVertexLine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLVertexLine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_coord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_coord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_coord_set" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_coord_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->coord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_coord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_coord_get" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  result = (SoSFNode *)& ((arg1)->coord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_color_set" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_color_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_color_get" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  result = (SoSFNode *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_colorPerVertex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_colorPerVertex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_colorPerVertex_set" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_colorPerVertex_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->colorPerVertex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_colorPerVertex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_colorPerVertex_get" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  result = (SoSFBool *)& ((arg1)->colorPerVertex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_doAction" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_GLRender" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_getBoundingBox" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_callback" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_pick" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexLine_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexLine *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexLine_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexLine_notify" "', argument " "1"" of type '" "SoVRMLVertexLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexLine_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLVertexLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLVertexLine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLIndexedLine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLine_getTypeId" "', argument " "1"" of type '" "SoVRMLIndexedLine const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLine * >(argp1);
  result = ((SoVRMLIndexedLine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLine_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLIndexedLine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_coordIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLine *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLine_coordIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLine_coordIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedLine_coordIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->coordIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_coordIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLine_coordIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLine * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->coordIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_colorIndex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLine *arg1 = 0 ;
  SoMFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLine_colorIndex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLine_colorIndex_set" "', argument " "1"" of type '" "SoVRMLIndexedLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedLine_colorIndex_set" "', argument " "2"" of type '" "SoMFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoMFInt32 * >(argp2);
  if (arg1) (arg1)->colorIndex = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLine_colorIndex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLine_colorIndex_get" "', argument " "1"" of type '" "SoVRMLIndexedLine *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLine * >(argp1);
  result = (SoMFInt32 *)& ((arg1)->colorIndex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLIndexedLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLIndexedLine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLineSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLIndexedLineSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLineSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLineSet_getTypeId" "', argument " "1"" of type '" "SoVRMLIndexedLineSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLineSet * >(argp1);
  result = ((SoVRMLIndexedLineSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLineSet_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLIndexedLineSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLIndexedLineSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLineSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLIndexedLineSet", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLIndexedLineSet *)new SoVRMLIndexedLineSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLIndexedLineSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLineSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLineSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLineSet_GLRender" "', argument " "1"" of type '" "SoVRMLIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedLineSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLineSet *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLineSet_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLineSet_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedLineSet_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLIndexedLineSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLIndexedLineSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLIndexedLineSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLIndexedLineSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLIndexedLineSet_getBoundingBox" "', argument " "1"" of type '" "SoVRMLIndexedLineSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLIndexedLineSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLIndexedLineSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLIndexedLineSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLIndexedLineSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLIndexedLineSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLInline_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLInline::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getTypeId" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = ((SoVRMLInline const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLInline::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLInline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLInline", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLInline *)new SoVRMLInline();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLInline, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_bboxCenter_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_bboxCenter_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_bboxCenter_set" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_bboxCenter_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxCenter = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_bboxCenter_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_bboxCenter_get" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxCenter);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_bboxSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_bboxSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_bboxSize_set" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_bboxSize_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->bboxSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_bboxSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_bboxSize_get" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->bboxSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_url_set" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_url_get" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_setFullURLName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_setFullURLName" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setFullURLName((SbString const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getFullURLName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getFullURLName" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SbString *) &(arg1)->getFullURLName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_copyChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGroup *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_copyChildren" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoGroup *)((SoVRMLInline const *)arg1)->copyChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGroup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_requestURLData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_requestURLData" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  (arg1)->requestURLData();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_isURLDataRequested(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_isURLDataRequested" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SbBool)((SoVRMLInline const *)arg1)->isURLDataRequested();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_isURLDataHere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_isURLDataHere" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SbBool)((SoVRMLInline const *)arg1)->isURLDataHere();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_cancelURLDataRequest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_cancelURLDataRequest" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  (arg1)->cancelURLDataRequest();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setChildData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_setChildData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_setChildData" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_setChildData" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setChildData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getChildData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getChildData" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoNode *)((SoVRMLInline const *)arg1)->getChildData();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setFetchURLCallBack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInlineFetchURLCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_setFetchURLCallBack", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLInline_setFetchURLCallBack" "', argument " "1"" of type '" "SoVRMLInlineFetchURLCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_setFetchURLCallBack" "', argument " "2"" of type '" "void *""'"); 
  }
  SoVRMLInline::setFetchURLCallBack(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setBoundingBoxVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline::BboxVisibility arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLInline_setBoundingBoxVisibility" "', argument " "1"" of type '" "SoVRMLInline::BboxVisibility""'");
  } 
  arg1 = static_cast< SoVRMLInline::BboxVisibility >(val1);
  SoVRMLInline::setBoundingBoxVisibility(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getBoundingBoxVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline::BboxVisibility result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getBoundingBoxVisibility", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLInline::BboxVisibility)SoVRMLInline::getBoundingBoxVisibility();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setBoundingBoxColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbColor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_setBoundingBoxColor" "', argument " "1"" of type '" "SbColor &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLInline_setBoundingBoxColor" "', argument " "1"" of type '" "SbColor &""'"); 
  }
  arg1 = reinterpret_cast< SbColor * >(argp1);
  SoVRMLInline::setBoundingBoxColor(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getBoundingBoxColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbColor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getBoundingBoxColor", 0, 0, 0)) SWIG_fail;
  result = (SbColor *) &SoVRMLInline::getBoundingBoxColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_setReadAsSoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLInline_setReadAsSoFile" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoVRMLInline::setReadAsSoFile(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getReadAsSoFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getReadAsSoFile", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoVRMLInline::getReadAsSoFile();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_doAction" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_callback" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_GLRender" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getBoundingBox" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getMatrix" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_handleEvent" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_search" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_pick" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLInline_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLInline *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLInline_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLInline_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLInline *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLInline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLInline_getChildren" "', argument " "1"" of type '" "SoVRMLInline const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLInline * >(argp1);
  result = (SoChildList *)((SoVRMLInline const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLInline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLInline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLInline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLLOD_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLLOD::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getTypeId" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = ((SoVRMLLOD const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLLOD::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLLOD__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLLOD *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLLOD *)new SoVRMLLOD();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLLOD, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLLOD__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLLOD *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLLOD" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLLOD *)new SoVRMLLOD(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLLOD, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLLOD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLLOD", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLLOD__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLLOD__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLLOD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLLOD::SoVRMLLOD()\n"
    "    SoVRMLLOD::SoVRMLLOD(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_range_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_range_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_range_set" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_range_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->range = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_range_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_range_get" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (SoMFFloat *)& ((arg1)->range);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_center_set" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_center_get" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_level_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_level_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_level_set" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_level_set" "', argument " "2"" of type '" "SoMFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  if (arg1) (arg1)->level = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_level_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_level_get" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (SoMFNode *)& ((arg1)->level);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_affectsState" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (SbBool)((SoVRMLLOD const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_addLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_addLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_addLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_addLevel" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_insertLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_insertLevel", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_insertLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_insertLevel" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLLOD_insertLevel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertLevel(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_getLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getLevel" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_getLevel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoVRMLLOD const *)arg1)->getLevel(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_findLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_findLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_findLevel" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_findLevel" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoVRMLLOD const *)arg1)->findLevel((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getNumLevels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getNumLevels" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (int)((SoVRMLLOD const *)arg1)->getNumLevels();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeLevel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_removeLevel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeLevel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_removeLevel" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeLevel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLLOD_removeLevel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLLOD_removeLevel__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVRMLLOD_removeLevel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLLOD_removeLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLLOD::removeLevel(int)\n"
    "    SoVRMLLOD::removeLevel(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeAllLevels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeAllLevels" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  (arg1)->removeAllLevels();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceLevel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceLevel(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceLevel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLLOD_replaceLevel" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceLevel(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceLevel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLLOD_replaceLevel", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLLOD_replaceLevel__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLLOD_replaceLevel__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLLOD_replaceLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLLOD::replaceLevel(int,SoNode *)\n"
    "    SoVRMLLOD::replaceLevel(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_doAction" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_callback" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_GLRender" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_rayPick" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getBoundingBox" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_search" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_write" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_audioRender" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_GLRenderBelowPath" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_GLRenderInPath" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_GLRenderOffPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_GLRenderOffPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_GLRenderOffPath" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_GLRenderOffPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderOffPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_addChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_addChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_addChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_insertChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_insertChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_insertChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLLOD_insertChild" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getChild" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_getChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoVRMLLOD const *)arg1)->getChild(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_findChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLLOD_findChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_findChild" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_findChild" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoVRMLLOD const *)arg1)->findChild((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getNumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getNumChildren" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (int)((SoVRMLLOD const *)arg1)->getNumChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_removeChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_removeChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLLOD_removeChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLLOD_removeChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVRMLLOD_removeChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLLOD_removeChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLLOD::removeChild(int)\n"
    "    SoVRMLLOD::removeChild(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_removeAllChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_removeAllChildren" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  (arg1)->removeAllChildren();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_replaceChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLLOD_replaceChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLLOD_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_replaceChild" "', argument " "1"" of type '" "SoVRMLLOD *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLLOD_replaceChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLLOD_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLLOD_replaceChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLLOD_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLLOD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLLOD_replaceChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLLOD_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLLOD::replaceChild(int,SoNode *)\n"
    "    SoVRMLLOD::replaceChild(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLLOD_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLLOD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLLOD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLLOD_getChildren" "', argument " "1"" of type '" "SoVRMLLOD const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLLOD * >(argp1);
  result = (SoChildList *)((SoVRMLLOD const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLLOD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLLOD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLLOD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLMaterial_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLMaterial::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_getTypeId" "', argument " "1"" of type '" "SoVRMLMaterial const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = ((SoVRMLMaterial const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLMaterial::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLMaterial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLMaterial", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLMaterial *)new SoVRMLMaterial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLMaterial, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_diffuseColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_diffuseColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_diffuseColor_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_diffuseColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->diffuseColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_diffuseColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_diffuseColor_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFColor *)& ((arg1)->diffuseColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_ambientIntensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_ambientIntensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_ambientIntensity_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_ambientIntensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->ambientIntensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_ambientIntensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_ambientIntensity_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFFloat *)& ((arg1)->ambientIntensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_specularColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_specularColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_specularColor_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_specularColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->specularColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_specularColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_specularColor_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFColor *)& ((arg1)->specularColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_emissiveColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_emissiveColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_emissiveColor_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_emissiveColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->emissiveColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_emissiveColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_emissiveColor_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFColor *)& ((arg1)->emissiveColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_shininess_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_shininess_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_shininess_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_shininess_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->shininess = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_shininess_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_shininess_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFFloat *)& ((arg1)->shininess);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_transparency_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_transparency_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_transparency_set" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_transparency_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->transparency = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_transparency_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_transparency_get" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  result = (SoSFFloat *)& ((arg1)->transparency);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_doAction" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_GLRender" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMaterial_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMaterial *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMaterial_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMaterial_callback" "', argument " "1"" of type '" "SoVRMLMaterial *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMaterial_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLMaterial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLMaterial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLMaterial_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLMovieTexture::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_getTypeId" "', argument " "1"" of type '" "SoVRMLMovieTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = ((SoVRMLMovieTexture const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLMovieTexture::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLMovieTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLMovieTexture", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLMovieTexture *)new SoVRMLMovieTexture();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLMovieTexture, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_loop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_loop_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_loop_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_loop_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->loop = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_loop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_loop_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFBool *)& ((arg1)->loop);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_speed_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_speed_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_startTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_startTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_startTime_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_startTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->startTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_startTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_startTime_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFTime *)& ((arg1)->startTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_stopTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_stopTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_stopTime_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_stopTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->stopTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_stopTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_stopTime_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFTime *)& ((arg1)->stopTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_pauseTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_pauseTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_pauseTime_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_pauseTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->pauseTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_pauseTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_pauseTime_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFTime *)& ((arg1)->pauseTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_resumeTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_resumeTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_resumeTime_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_resumeTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->resumeTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_resumeTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_resumeTime_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFTime *)& ((arg1)->resumeTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_url_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_url_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_duration_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_duration_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_duration_changed_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_duration_changed_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->duration_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_duration_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_duration_changed_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFTime *)& ((arg1)->duration_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_isActive_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_isActive_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_alpha_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_alpha_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_alpha_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_alpha_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->alpha = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_alpha_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFFloat *)& ((arg1)->alpha);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_model_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_model_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_model_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_model_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->model = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_model_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_model_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFEnum *)& ((arg1)->model);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_blendColor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFColor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_blendColor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_blendColor_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFColor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_blendColor_set" "', argument " "2"" of type '" "SoSFColor *""'"); 
  }
  arg2 = reinterpret_cast< SoSFColor * >(argp2);
  if (arg1) (arg1)->blendColor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_blendColor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFColor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_blendColor_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFColor *)& ((arg1)->blendColor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_scaleTexCoord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_scaleTexCoord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_scaleTexCoord_set" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_scaleTexCoord_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->scaleTexCoord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_scaleTexCoord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_scaleTexCoord_get" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  result = (SoSFBool *)& ((arg1)->scaleTexCoord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLMovieTexture_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLMovieTexture *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLMovieTexture_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLMovieTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLMovieTexture_GLRender" "', argument " "1"" of type '" "SoVRMLMovieTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLMovieTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLMovieTexture_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLMovieTexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLMovieTexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLMovieTexture_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLNavigationInfo::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_getTypeId" "', argument " "1"" of type '" "SoVRMLNavigationInfo const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = ((SoVRMLNavigationInfo const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLNavigationInfo::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLNavigationInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLNavigationInfo", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLNavigationInfo *)new SoVRMLNavigationInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLNavigationInfo, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_type_set" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_type_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_type_get" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = (SoMFString *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_speed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_speed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_speed_set" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_speed_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->speed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_speed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_speed_get" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = (SoSFFloat *)& ((arg1)->speed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_avatarSize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_avatarSize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_avatarSize_set" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_avatarSize_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->avatarSize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_avatarSize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_avatarSize_get" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = (SoMFFloat *)& ((arg1)->avatarSize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_visibilityLimit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_visibilityLimit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_visibilityLimit_set" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_visibilityLimit_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->visibilityLimit = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_visibilityLimit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_visibilityLimit_get" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = (SoSFFloat *)& ((arg1)->visibilityLimit);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_headlight_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_headlight_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_headlight_set" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_headlight_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->headlight = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_headlight_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_headlight_get" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  result = (SoSFBool *)& ((arg1)->headlight);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNavigationInfo_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNavigationInfo *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNavigationInfo_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNavigationInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNavigationInfo_GLRender" "', argument " "1"" of type '" "SoVRMLNavigationInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNavigationInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNavigationInfo_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLNavigationInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLNavigationInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLNavigationInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLNormal_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLNormal::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_getTypeId" "', argument " "1"" of type '" "SoVRMLNormal const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  result = ((SoVRMLNormal const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLNormal::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLNormal", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLNormal *)new SoVRMLNormal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLNormal, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_vector_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_vector_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_vector_set" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_vector_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->vector = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_vector_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_vector_get" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->vector);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_doAction" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_GLRender" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_callback" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_pick" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormal_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormal *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormal_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormal_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLNormal *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormal_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormalInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLNormalInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLNormalInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  result = ((SoVRMLNormalInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLNormalInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLNormalInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormalInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLNormalInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormalInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLNormalInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLNormalInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLNormalInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLNormalInterpolator *)new SoVRMLNormalInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLNormalInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormalInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLNormalInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormalInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLNormalInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLNormalInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLNormalInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLNormalInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLNormalInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLNormalInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLNormalInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLNormalInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLNormalInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLNormalInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLNormalInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLNormalInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLNormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLOrientationInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLOrientationInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  result = ((SoVRMLOrientationInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLOrientationInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLOrientationInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLOrientationInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLOrientationInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLOrientationInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLOrientationInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLOrientationInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLOrientationInterpolator *)new SoVRMLOrientationInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLOrientationInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  SoMFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLOrientationInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLOrientationInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoMFRotation * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  result = (SoMFRotation *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLOrientationInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLOrientationInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLOrientationInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLOrientationInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLOrientationInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLOrientationInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLOrientationInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLOrientationInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLOrientationInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLOrientationInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLOrientationInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLPixelTexture::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_getTypeId" "', argument " "1"" of type '" "SoVRMLPixelTexture const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  result = ((SoVRMLPixelTexture const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLPixelTexture::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLPixelTexture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLPixelTexture", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLPixelTexture *)new SoVRMLPixelTexture();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLPixelTexture, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_image_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  SoSFImage *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_image_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_image_set" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPixelTexture_image_set" "', argument " "2"" of type '" "SoSFImage *""'"); 
  }
  arg2 = reinterpret_cast< SoSFImage * >(argp2);
  if (arg1) (arg1)->image = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_image_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFImage *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_image_get" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  result = (SoSFImage *)& ((arg1)->image);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFImage, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_doAction" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPixelTexture_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_GLRender" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPixelTexture_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_callback" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPixelTexture_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPixelTexture_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPixelTexture *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPixelTexture_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPixelTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPixelTexture_rayPick" "', argument " "1"" of type '" "SoVRMLPixelTexture *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPixelTexture * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPixelTexture_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLPixelTexture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLPixelTexture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLPixelTexture_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLPlaneSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLPlaneSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  result = ((SoVRMLPlaneSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLPlaneSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLPlaneSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLPlaneSensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLPlaneSensor *)new SoVRMLPlaneSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLPlaneSensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_minPosition_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_minPosition_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_minPosition_set" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPlaneSensor_minPosition_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->minPosition = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_minPosition_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_minPosition_get" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->minPosition);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_maxPosition_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_maxPosition_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_maxPosition_set" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPlaneSensor_maxPosition_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->maxPosition = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_maxPosition_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_maxPosition_get" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->maxPosition);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_offset_set" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPlaneSensor_offset_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_offset_get" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_translation_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPlaneSensor_translation_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_translation_changed_set" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPlaneSensor_translation_changed_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPlaneSensor_translation_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPlaneSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPlaneSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPlaneSensor_translation_changed_get" "', argument " "1"" of type '" "SoVRMLPlaneSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPlaneSensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLPlaneSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLPlaneSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLPlaneSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLPointLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLPointLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_getTypeId" "', argument " "1"" of type '" "SoVRMLPointLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  result = ((SoVRMLPointLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLPointLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLPointLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLPointLight", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLPointLight *)new SoVRMLPointLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLPointLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_location_set" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointLight_location_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_location_get" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_radius_set" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointLight_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_radius_get" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_attenuation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_attenuation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_attenuation_set" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointLight_attenuation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->attenuation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_attenuation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_attenuation_get" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->attenuation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointLight_GLRender" "', argument " "1"" of type '" "SoVRMLPointLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLPointLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLPointLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLPointLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLVertexPoint::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_getTypeId" "', argument " "1"" of type '" "SoVRMLVertexPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  result = ((SoVRMLVertexPoint const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLVertexPoint::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_coord_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_coord_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_coord_set" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_coord_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->coord = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_coord_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_coord_get" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  result = (SoSFNode *)& ((arg1)->coord);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_color_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_color_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_color_set" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_color_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->color = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_color_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_color_get" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  result = (SoSFNode *)& ((arg1)->color);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_doAction" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_GLRender" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_getBoundingBox" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_callback" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_pick" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVertexPoint_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVertexPoint *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVertexPoint_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVertexPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVertexPoint_notify" "', argument " "1"" of type '" "SoVRMLVertexPoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVertexPoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVertexPoint_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLVertexPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLVertexPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoVRMLPointSet_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointSet_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLPointSet::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointSet_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointSet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointSet_getTypeId" "', argument " "1"" of type '" "SoVRMLPointSet const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointSet * >(argp1);
  result = ((SoVRMLPointSet const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointSet_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointSet_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLPointSet::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLPointSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLPointSet", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLPointSet *)new SoVRMLPointSet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLPointSet, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointSet_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointSet *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointSet_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointSet_GLRender" "', argument " "1"" of type '" "SoVRMLPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointSet_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPointSet_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPointSet *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPointSet_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPointSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPointSet_getBoundingBox" "', argument " "1"" of type '" "SoVRMLPointSet *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPointSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPointSet_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLPointSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLPointSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLPointSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPositionInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLPositionInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLPositionInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  result = ((SoVRMLPositionInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLPositionInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLPositionInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPositionInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLPositionInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPositionInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLPositionInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLPositionInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLPositionInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLPositionInterpolator *)new SoVRMLPositionInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLPositionInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  SoMFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPositionInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLPositionInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPositionInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec3f * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLPositionInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  result = (SoMFVec3f *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLPositionInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLPositionInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLPositionInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLPositionInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLPositionInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLPositionInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLPositionInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLPositionInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLPositionInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLPositionInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLPositionInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLPositionInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLProximitySensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_getTypeId" "', argument " "1"" of type '" "SoVRMLProximitySensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = ((SoVRMLProximitySensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLProximitySensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLProximitySensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLProximitySensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLProximitySensor *)new SoVRMLProximitySensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLProximitySensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_center_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_center_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_size_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_size_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_size_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_enabled_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_enabled_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enabled = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_enabled_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->enabled);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_isActive_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_isActive_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_position_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_position_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_position_changed_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_position_changed_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->position_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_position_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_position_changed_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->position_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_orientation_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_orientation_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_orientation_changed_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_orientation_changed_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->orientation_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_orientation_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_orientation_changed_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFRotation *)& ((arg1)->orientation_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_enterTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_enterTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_enterTime_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_enterTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->enterTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_enterTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_enterTime_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->enterTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_exitTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_exitTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_exitTime_set" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_exitTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->exitTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_exitTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_exitTime_get" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->exitTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_affectsState" "', argument " "1"" of type '" "SoVRMLProximitySensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  result = (SbBool)((SoVRMLProximitySensor const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_doAction" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_GLRender" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_callback" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_rayPick" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLProximitySensor_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLProximitySensor *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLProximitySensor_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLProximitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLProximitySensor_getBoundingBox" "', argument " "1"" of type '" "SoVRMLProximitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLProximitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLProximitySensor_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLProximitySensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLProximitySensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLProximitySensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScalarInterpolator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLScalarInterpolator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_getTypeId" "', argument " "1"" of type '" "SoVRMLScalarInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  result = ((SoVRMLScalarInterpolator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_getOutputData" "', argument " "1"" of type '" "SoVRMLScalarInterpolator const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLScalarInterpolator const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScalarInterpolator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLScalarInterpolator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScalarInterpolator_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLScalarInterpolator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLScalarInterpolator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLScalarInterpolator", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLScalarInterpolator *)new SoVRMLScalarInterpolator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLScalarInterpolator, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_keyValue_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScalarInterpolator_keyValue_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_keyValue_set" "', argument " "1"" of type '" "SoVRMLScalarInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScalarInterpolator_keyValue_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->keyValue = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_keyValue_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_keyValue_get" "', argument " "1"" of type '" "SoVRMLScalarInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  result = (SoMFFloat *)& ((arg1)->keyValue);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_value_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScalarInterpolator_value_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_value_changed_set" "', argument " "1"" of type '" "SoVRMLScalarInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScalarInterpolator_value_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->value_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScalarInterpolator_value_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScalarInterpolator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScalarInterpolator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScalarInterpolator_value_changed_get" "', argument " "1"" of type '" "SoVRMLScalarInterpolator *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScalarInterpolator * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->value_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLScalarInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLScalarInterpolator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLScalarInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLScript_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLScript::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLScript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLScript", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLScript *)new SoVRMLScript();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLScript, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLScript::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_getTypeId" "', argument " "1"" of type '" "SoVRMLScript const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  result = ((SoVRMLScript const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_url_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_url_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_url_set" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_url_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->url = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_url_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_url_get" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  result = (SoMFString *)& ((arg1)->url);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_directOutput_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_directOutput_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_directOutput_set" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_directOutput_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->directOutput = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_directOutput_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_directOutput_get" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  result = (SoSFBool *)& ((arg1)->directOutput);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_mustEvaluate_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_mustEvaluate_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_mustEvaluate_set" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_mustEvaluate_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->mustEvaluate = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_mustEvaluate_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_mustEvaluate_get" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  result = (SoSFBool *)& ((arg1)->mustEvaluate);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_doAction" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_callback" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_GLRender" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_getBoundingBox" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_pick" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_handleEvent" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScript *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLScript, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLScript_write" "', argument " "1"" of type '" "SoVRMLScript *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLScript * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLScript_setScriptEvaluateCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLScriptEvaluateCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLScript_setScriptEvaluateCB", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_SoVRMLScript__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoVRMLScript_setScriptEvaluateCB" "', argument " "1"" of type '" "SoVRMLScriptEvaluateCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLScript_setScriptEvaluateCB" "', argument " "2"" of type '" "void *""'"); 
  }
  SoVRMLScript::setScriptEvaluateCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLScript_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLScript, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLScript_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLShape_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLShape::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_getTypeId" "', argument " "1"" of type '" "SoVRMLShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = ((SoVRMLShape const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLShape::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLShape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLShape", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLShape *)new SoVRMLShape();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLShape, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_appearance_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_appearance_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_appearance_set" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_appearance_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->appearance = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_appearance_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_appearance_get" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->appearance);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_geometry_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_geometry_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_geometry_set" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_geometry_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->geometry = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_geometry_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_geometry_get" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SoSFNode *)& ((arg1)->geometry);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_renderCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_renderCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_renderCaching_set" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_renderCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->renderCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_renderCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_renderCaching_get" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SoSFEnum *)& ((arg1)->renderCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_boundingBoxCaching_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoSFEnum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_boundingBoxCaching_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_boundingBoxCaching_set" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFEnum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_boundingBoxCaching_set" "', argument " "2"" of type '" "SoSFEnum *""'"); 
  }
  arg2 = reinterpret_cast< SoSFEnum * >(argp2);
  if (arg1) (arg1)->boundingBoxCaching = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_boundingBoxCaching_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFEnum *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_boundingBoxCaching_get" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SoSFEnum *)& ((arg1)->boundingBoxCaching);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFEnum, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_setNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLShape_setNumRenderCaches" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  SoVRMLShape::setNumRenderCaches(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_getNumRenderCaches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_getNumRenderCaches", 0, 0, 0)) SWIG_fail;
  result = (int)SoVRMLShape::getNumRenderCaches();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_affectsState" "', argument " "1"" of type '" "SoVRMLShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SbBool)((SoVRMLShape const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_doAction" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_callback" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_GLRender" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_getBoundingBox" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_rayPick" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_search" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_write" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_getChildren" "', argument " "1"" of type '" "SoVRMLShape const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  result = (SoChildList *)((SoVRMLShape const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_notify" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLShape_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLShape *arg1 = 0 ;
  SoFieldContainer *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLShape_copyContents", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLShape_copyContents" "', argument " "1"" of type '" "SoVRMLShape *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLShape * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoFieldContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLShape_copyContents" "', argument " "2"" of type '" "SoFieldContainer const *""'"); 
  }
  arg2 = reinterpret_cast< SoFieldContainer * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLShape_copyContents" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->copyContents((SoFieldContainer const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLShape_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSound_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSound::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_getTypeId" "', argument " "1"" of type '" "SoVRMLSound const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = ((SoVRMLSound const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSound::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLSound", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLSound *)new SoVRMLSound();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSound, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_source_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_source_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_source_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_source_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->source = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_source_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_source_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFNode *)& ((arg1)->source);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_intensity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_intensity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_intensity_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_intensity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->intensity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_intensity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_intensity_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->intensity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_priority_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_priority_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_priority_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_priority_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->priority = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_priority_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_priority_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->priority);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_location_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_location_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_location_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_direction_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_direction_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_direction_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_minFront_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_minFront_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_minFront_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_minFront_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->minFront = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_minFront_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_minFront_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->minFront);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_maxFront_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_maxFront_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_maxFront_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_maxFront_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->maxFront = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_maxFront_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_maxFront_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->maxFront);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_minBack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_minBack_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_minBack_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_minBack_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->minBack = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_minBack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_minBack_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->minBack);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_maxBack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_maxBack_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_maxBack_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_maxBack_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->maxBack = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_maxBack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_maxBack_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->maxBack);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_spatialize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_spatialize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_spatialize_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_spatialize_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->spatialize = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_spatialize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_spatialize_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFBool *)& ((arg1)->spatialize);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_dopplerFactor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_dopplerFactor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_dopplerFactor_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_dopplerFactor_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->dopplerFactor = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_dopplerFactor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_dopplerFactor_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->dopplerFactor);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_dopplerVelocity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_dopplerVelocity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_dopplerVelocity_set" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_dopplerVelocity_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->dopplerVelocity = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_dopplerVelocity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_dopplerVelocity_get" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (SoSFFloat *)& ((arg1)->dopplerVelocity);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_setDopplerVelocity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_setDopplerVelocity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_setDopplerVelocity" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSound_setDopplerVelocity" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setDopplerVelocity(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_getDopplerVelocity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_getDopplerVelocity" "', argument " "1"" of type '" "SoVRMLSound const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (float)((SoVRMLSound const *)arg1)->getDopplerVelocity();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_setDopplerFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_setDopplerFactor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_setDopplerFactor" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSound_setDopplerFactor" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setDopplerFactor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_getDopplerFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_getDopplerFactor" "', argument " "1"" of type '" "SoVRMLSound const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  result = (float)((SoVRMLSound const *)arg1)->getDopplerFactor();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_startPlaying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_startPlaying", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_startPlaying" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_startPlaying" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSound_startPlaying" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->startPlaying(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_stopPlaying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoPath *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_stopPlaying", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_stopPlaying" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_stopPlaying" "', argument " "2"" of type '" "SoPath *""'"); 
  }
  arg2 = reinterpret_cast< SoPath * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSound_stopPlaying" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->stopPlaying(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_setDefaultBufferingProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  SbTime arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_setDefaultBufferingProperties", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoVRMLSound_setDefaultBufferingProperties" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSound_setDefaultBufferingProperties" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSound_setDefaultBufferingProperties" "', argument " "3"" of type '" "SbTime""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLSound_setDefaultBufferingProperties" "', argument " "3"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  SoVRMLSound::setDefaultBufferingProperties(arg1,arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_setBufferingProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbTime arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_setBufferingProperties", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_setBufferingProperties" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSound_setBufferingProperties" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLSound_setBufferingProperties" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbTime,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoVRMLSound_setBufferingProperties" "', argument " "4"" of type '" "SbTime""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLSound_setBufferingProperties" "', argument " "4"" of type '" "SbTime""'");
    } else {
      SbTime * temp = reinterpret_cast< SbTime * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  (arg1)->setBufferingProperties(arg2,arg3,SWIG_STD_MOVE(arg4));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_getBufferingProperties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  SbTime *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_getBufferingProperties", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_getBufferingProperties" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_getBufferingProperties" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLSound_getBufferingProperties" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSound_getBufferingProperties" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLSound_getBufferingProperties" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  {
    if (PyFloat_Check(swig_obj[3])) {
      arg4 = new SbTime(PyFloat_AsDouble(swig_obj[3]));
    } else {
      SbTime * tmp = NULL;
      arg4 = new SbTime;
      
      
      
      SWIG_ConvertPtr(swig_obj[3], (void**)&tmp, SWIGTYPE_p_SbTime, 1);
      
      *arg4 = *tmp;
    }
  }
  (arg1)->getBufferingProperties(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return resultobj;
fail:
  {
    if (arg4) {
      delete arg4; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSound_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSound *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSound_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSound_audioRender" "', argument " "1"" of type '" "SoVRMLSound *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSound * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSound_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSound, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLSound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSphere_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSphere::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_getTypeId" "', argument " "1"" of type '" "SoVRMLSphere const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  result = ((SoVRMLSphere const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSphere::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSphere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLSphere", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLSphere *)new SoVRMLSphere();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSphere, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_radius_set" "', argument " "1"" of type '" "SoVRMLSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphere_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_radius_get" "', argument " "1"" of type '" "SoVRMLSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_GLRender" "', argument " "1"" of type '" "SoVRMLSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphere_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_rayPick" "', argument " "1"" of type '" "SoVRMLSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphere_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphere_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphere *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphere_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphere_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLSphere *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphere_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSphere_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSphere, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLSphere_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphereSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSphereSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphereSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphereSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLSphereSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphereSensor * >(argp1);
  result = ((SoVRMLSphereSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphereSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSphereSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSphereSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLSphereSensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLSphereSensor *)new SoVRMLSphereSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSphereSensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphereSensor_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphereSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphereSensor_offset_set" "', argument " "1"" of type '" "SoVRMLSphereSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphereSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphereSensor_offset_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->offset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphereSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphereSensor_offset_get" "', argument " "1"" of type '" "SoVRMLSphereSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphereSensor * >(argp1);
  result = (SoSFRotation *)& ((arg1)->offset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_rotation_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSphereSensor_rotation_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphereSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphereSensor_rotation_changed_set" "', argument " "1"" of type '" "SoVRMLSphereSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphereSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSphereSensor_rotation_changed_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSphereSensor_rotation_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSphereSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSphereSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSphereSensor_rotation_changed_get" "', argument " "1"" of type '" "SoVRMLSphereSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSphereSensor * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSphereSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSphereSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLSphereSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSpotLight::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_getTypeId" "', argument " "1"" of type '" "SoVRMLSpotLight const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = ((SoVRMLSpotLight const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSpotLight::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSpotLight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLSpotLight", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLSpotLight *)new SoVRMLSpotLight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSpotLight, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_location_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_location_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_location_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_location_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->location = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_location_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_location_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->location);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_direction_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_direction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_direction_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_direction_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_direction_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_direction_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->direction);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_beamWidth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_beamWidth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_beamWidth_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_beamWidth_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->beamWidth = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_beamWidth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_beamWidth_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->beamWidth);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_cutOffAngle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_cutOffAngle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_cutOffAngle_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_cutOffAngle_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->cutOffAngle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_cutOffAngle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_cutOffAngle_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->cutOffAngle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_radius_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_radius_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_radius_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_radius_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->radius = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_radius_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_radius_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFFloat *)& ((arg1)->radius);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_attenuation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_attenuation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_attenuation_set" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_attenuation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->attenuation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_attenuation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_attenuation_get" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->attenuation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSpotLight_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSpotLight *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSpotLight_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSpotLight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSpotLight_GLRender" "', argument " "1"" of type '" "SoVRMLSpotLight *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSpotLight * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSpotLight_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSpotLight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSpotLight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLSpotLight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLSwitch::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getTypeId" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = ((SoVRMLSwitch const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLSwitch::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSwitch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLSwitch *)new SoVRMLSwitch();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSwitch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLSwitch *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLSwitch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLSwitch *)new SoVRMLSwitch(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLSwitch, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLSwitch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLSwitch", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLSwitch__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLSwitch__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLSwitch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLSwitch::SoVRMLSwitch()\n"
    "    SoVRMLSwitch::SoVRMLSwitch(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_choice_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoMFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_choice_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_choice_set" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_choice_set" "', argument " "2"" of type '" "SoMFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoMFNode * >(argp2);
  if (arg1) (arg1)->choice = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_choice_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_choice_get" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (SoMFNode *)& ((arg1)->choice);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_whichChoice_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoSFInt32 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_whichChoice_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_whichChoice_set" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFInt32, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_whichChoice_set" "', argument " "2"" of type '" "SoSFInt32 *""'"); 
  }
  arg2 = reinterpret_cast< SoSFInt32 * >(argp2);
  if (arg1) (arg1)->whichChoice = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_whichChoice_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFInt32 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_whichChoice_get" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (SoSFInt32 *)& ((arg1)->whichChoice);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFInt32, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_affectsState" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (SbBool)((SoVRMLSwitch const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_addChoice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_addChoice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_addChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_addChoice" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChoice(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_insertChoice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_insertChoice", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_insertChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_insertChoice" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLSwitch_insertChoice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChoice(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getChoice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_getChoice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getChoice" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_getChoice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoVRMLSwitch const *)arg1)->getChoice(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_findChoice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_findChoice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_findChoice" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_findChoice" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoVRMLSwitch const *)arg1)->findChoice(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getNumChoices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getNumChoices" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (int)((SoVRMLSwitch const *)arg1)->getNumChoices();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChoice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_removeChoice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChoice(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChoice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_removeChoice" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChoice(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChoice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_removeChoice", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLSwitch_removeChoice__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVRMLSwitch_removeChoice__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLSwitch_removeChoice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLSwitch::removeChoice(int)\n"
    "    SoVRMLSwitch::removeChoice(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeAllChoices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeAllChoices" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  (arg1)->removeAllChoices();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChoice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChoice(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChoice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSwitch_replaceChoice" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChoice(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChoice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_replaceChoice", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLSwitch_replaceChoice__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLSwitch_replaceChoice__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLSwitch_replaceChoice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLSwitch::replaceChoice(int,SoNode *)\n"
    "    SoVRMLSwitch::replaceChoice(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_doAction" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_callback" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_GLRender" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_pick" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getBoundingBox" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_handleEvent" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getMatrix" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoSearchAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_search", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_search" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSearchAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_search" "', argument " "2"" of type '" "SoSearchAction *""'"); 
  }
  arg2 = reinterpret_cast< SoSearchAction * >(argp2);
  (arg1)->search(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_write" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_audioRender" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_addChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_addChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_addChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->addChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_insertChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_insertChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_insertChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoVRMLSwitch_insertChild" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getChild" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_getChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoNode *)((SoVRMLSwitch const *)arg1)->getChild(arg2);
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_findChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_findChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_findChild" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_findChild" "', argument " "2"" of type '" "SoNode const *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (int)((SoVRMLSwitch const *)arg1)->findChild((SoNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getNumChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getNumChildren" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (int)((SoVRMLSwitch const *)arg1)->getNumChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_removeChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_removeChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->removeChild(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_removeChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoVRMLSwitch_removeChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoVRMLSwitch_removeChild__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLSwitch_removeChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLSwitch::removeChild(int)\n"
    "    SoVRMLSwitch::removeChild(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_removeAllChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_removeAllChildren" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  (arg1)->removeAllChildren();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChild__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  int arg2 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChild__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  SoNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "1"" of type '" "SoVRMLSwitch *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLSwitch_replaceChild" "', argument " "3"" of type '" "SoNode *""'"); 
  }
  arg3 = reinterpret_cast< SoNode * >(argp3);
  (arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoVRMLSwitch_replaceChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLSwitch_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoVRMLSwitch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SoNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoVRMLSwitch_replaceChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoVRMLSwitch_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLSwitch::replaceChild(int,SoNode *)\n"
    "    SoVRMLSwitch::replaceChild(SoNode *,SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLSwitch_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLSwitch *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLSwitch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLSwitch_getChildren" "', argument " "1"" of type '" "SoVRMLSwitch const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLSwitch * >(argp1);
  result = (SoChildList *)((SoVRMLSwitch const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLSwitch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLSwitch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLSwitch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLText_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLText::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_getTypeId" "', argument " "1"" of type '" "SoVRMLText const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = ((SoVRMLText const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLText::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLText", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLText *)new SoVRMLText();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLText, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_string_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_string_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_string_set" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_string_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->string = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_string_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_string_get" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = (SoMFString *)& ((arg1)->string);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_fontStyle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoSFNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_fontStyle_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_fontStyle_set" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_fontStyle_set" "', argument " "2"" of type '" "SoSFNode *""'"); 
  }
  arg2 = reinterpret_cast< SoSFNode * >(argp2);
  if (arg1) (arg1)->fontStyle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_fontStyle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_fontStyle_get" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = (SoSFNode *)& ((arg1)->fontStyle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_maxExtent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_maxExtent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_maxExtent_set" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_maxExtent_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->maxExtent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_maxExtent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_maxExtent_get" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = (SoSFFloat *)& ((arg1)->maxExtent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoMFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_length_set" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_length_set" "', argument " "2"" of type '" "SoMFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoMFFloat * >(argp2);
  if (arg1) (arg1)->length = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_length_get" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = (SoMFFloat *)& ((arg1)->length);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_GLRender" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLText_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_notify" "', argument " "1"" of type '" "SoVRMLText *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLText_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLText_getChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoChildList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLText_getChildren" "', argument " "1"" of type '" "SoVRMLText const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLText * >(argp1);
  result = (SoChildList *)((SoVRMLText const *)arg1)->getChildren();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoChildList, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTextureCoordinate::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_getTypeId" "', argument " "1"" of type '" "SoVRMLTextureCoordinate const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  result = ((SoVRMLTextureCoordinate const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTextureCoordinate::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTextureCoordinate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLTextureCoordinate", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLTextureCoordinate *)new SoVRMLTextureCoordinate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTextureCoordinate, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_point_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoMFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_point_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_point_set" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_point_set" "', argument " "2"" of type '" "SoMFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoMFVec2f * >(argp2);
  if (arg1) (arg1)->point = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_point_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_point_get" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  result = (SoMFVec2f *)& ((arg1)->point);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_doAction" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_callback" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_GLRender" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_pick" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureCoordinate_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureCoordinate *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureCoordinate_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureCoordinate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureCoordinate_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLTextureCoordinate *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureCoordinate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureCoordinate_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTextureCoordinate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTextureCoordinate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLTextureCoordinate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTextureTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_getTypeId" "', argument " "1"" of type '" "SoVRMLTextureTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  result = ((SoVRMLTextureTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTextureTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTextureTransform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLTextureTransform", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLTextureTransform *)new SoVRMLTextureTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTextureTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_translation_set" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_translation_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_translation_get" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_rotation_set" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_rotation_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_rotation_get" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  result = (SoSFFloat *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_scale_set" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_scale_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_scale_get" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_center_set" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_center_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_center_get" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_doAction" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_callback" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_GLRender" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_getMatrix" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTextureTransform_pick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTextureTransform *arg1 = 0 ;
  SoPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTextureTransform_pick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTextureTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTextureTransform_pick" "', argument " "1"" of type '" "SoVRMLTextureTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTextureTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTextureTransform_pick" "', argument " "2"" of type '" "SoPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoPickAction * >(argp2);
  (arg1)->pick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTextureTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTextureTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLTextureTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTimeSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLTimeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = ((SoVRMLTimeSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_getOutputData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutputData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_getOutputData" "', argument " "1"" of type '" "SoVRMLTimeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoEngineOutputData *)((SoVRMLTimeSensor const *)arg1)->getOutputData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutputData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoVRMLTimeSensor::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTimeSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTimeSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLTimeSensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLTimeSensor *)new SoVRMLTimeSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTimeSensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_cycleInterval_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_cycleInterval_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_cycleInterval_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_cycleInterval_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->cycleInterval = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_cycleInterval_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_cycleInterval_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->cycleInterval);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_enabled_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_enabled_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enabled = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_enabled_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->enabled);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_loop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_loop_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_loop_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_loop_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->loop = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_loop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_loop_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->loop);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_startTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_startTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_startTime_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_startTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->startTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_startTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_startTime_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->startTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_stopTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_stopTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_stopTime_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_stopTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->stopTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_stopTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_stopTime_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->stopTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_notify" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_handleEvent" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoWriteAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_write" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoWriteAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_write" "', argument " "2"" of type '" "SoWriteAction *""'"); 
  }
  arg2 = reinterpret_cast< SoWriteAction * >(argp2);
  (arg1)->write(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_cycleTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_cycleTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_cycleTime_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_cycleTime_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->cycleTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_cycleTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_cycleTime_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->cycleTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_fraction_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_fraction_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_fraction_changed_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_fraction_changed_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->fraction_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_fraction_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_fraction_changed_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->fraction_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_isActive_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_isActive_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_isActive_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_time_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  SoEngineOutput *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTimeSensor_time_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_time_set" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTimeSensor_time_set" "', argument " "2"" of type '" "SoEngineOutput *""'"); 
  }
  arg2 = reinterpret_cast< SoEngineOutput * >(argp2);
  if (arg1) (arg1)->time = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTimeSensor_time_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTimeSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEngineOutput *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTimeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTimeSensor_time_get" "', argument " "1"" of type '" "SoVRMLTimeSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTimeSensor * >(argp1);
  result = (SoEngineOutput *)& ((arg1)->time);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEngineOutput, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTimeSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTimeSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLTimeSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTouchSensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_getTypeId" "', argument " "1"" of type '" "SoVRMLTouchSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = ((SoVRMLTouchSensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTouchSensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTouchSensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLTouchSensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLTouchSensor *)new SoVRMLTouchSensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTouchSensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_enabled_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_enabled_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enabled = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_enabled_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->enabled);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitNormal_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_hitNormal_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitNormal_changed_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_hitNormal_changed_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->hitNormal_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitNormal_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitNormal_changed_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->hitNormal_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitPoint_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_hitPoint_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitPoint_changed_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_hitPoint_changed_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->hitPoint_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitPoint_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitPoint_changed_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->hitPoint_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitTexCoord_changed_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFVec2f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_hitTexCoord_changed_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitTexCoord_changed_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_hitTexCoord_changed_set" "', argument " "2"" of type '" "SoSFVec2f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec2f * >(argp2);
  if (arg1) (arg1)->hitTexCoord_changed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_hitTexCoord_changed_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec2f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_hitTexCoord_changed_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFVec2f *)& ((arg1)->hitTexCoord_changed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec2f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_isActive_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_isActive_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_isOver_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_isOver_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_isOver_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_isOver_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isOver = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_isOver_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_isOver_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->isOver);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_touchTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_touchTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_touchTime_set" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_touchTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->touchTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_touchTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_touchTime_get" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->touchTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_affectsState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_affectsState" "', argument " "1"" of type '" "SoVRMLTouchSensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  result = (SbBool)((SoVRMLTouchSensor const *)arg1)->affectsState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTouchSensor_handleEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTouchSensor *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTouchSensor_handleEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTouchSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTouchSensor_handleEvent" "', argument " "1"" of type '" "SoVRMLTouchSensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTouchSensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTouchSensor_handleEvent" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->handleEvent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTouchSensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTouchSensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLTouchSensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLTransform_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLTransform::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getTypeId" "', argument " "1"" of type '" "SoVRMLTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = ((SoVRMLTransform const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLTransform::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTransform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SoVRMLTransform *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SoVRMLTransform *)new SoVRMLTransform();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTransform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoVRMLTransform *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SoVRMLTransform" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoVRMLTransform *)new SoVRMLTransform(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLTransform, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLTransform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoVRMLTransform", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoVRMLTransform__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SoVRMLTransform__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoVRMLTransform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoVRMLTransform::SoVRMLTransform()\n"
    "    SoVRMLTransform::SoVRMLTransform(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_translation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_translation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_translation_set" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_translation_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->translation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_translation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_translation_get" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->translation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_rotation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_rotation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_rotation_set" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_rotation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_rotation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_rotation_get" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->rotation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_scale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_scale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_scale_set" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_scale_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->scale = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_scale_get" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->scale);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_scaleOrientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_scaleOrientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_scaleOrientation_set" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_scaleOrientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->scaleOrientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_scaleOrientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_scaleOrientation_get" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = (SoSFRotation *)& ((arg1)->scaleOrientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_center_set" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_center_get" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_pointAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_pointAt", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_pointAt" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_pointAt" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLTransform_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_pointAt" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  (arg1)->pointAt((SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getScaleSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getScaleSpaceMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getScaleSpaceMatrix" "', argument " "1"" of type '" "SoVRMLTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLTransform_getScaleSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_getScaleSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoVRMLTransform const *)arg1)->getScaleSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getRotationSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getRotationSpaceMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getRotationSpaceMatrix" "', argument " "1"" of type '" "SoVRMLTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLTransform_getRotationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_getRotationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoVRMLTransform const *)arg1)->getRotationSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getTranslationSpaceMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  SbMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getTranslationSpaceMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getTranslationSpaceMatrix" "', argument " "1"" of type '" "SoVRMLTransform const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3, SWIGTYPE_p_SbMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoVRMLTransform_getTranslationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_getTranslationSpaceMatrix" "', argument " "3"" of type '" "SbMatrix &""'"); 
  }
  arg3 = reinterpret_cast< SbMatrix * >(argp3);
  ((SoVRMLTransform const *)arg1)->getTranslationSpaceMatrix(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_multLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_multLeft" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  (arg1)->multLeft((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_multRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_multRight" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  (arg1)->multRight((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_combineLeft(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoVRMLTransform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_combineLeft", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_combineLeft" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_combineLeft" "', argument " "2"" of type '" "SoVRMLTransform *""'"); 
  }
  arg2 = reinterpret_cast< SoVRMLTransform * >(argp2);
  (arg1)->combineLeft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_combineRight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoVRMLTransform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_combineRight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_combineRight" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_combineRight" "', argument " "2"" of type '" "SoVRMLTransform *""'"); 
  }
  arg2 = reinterpret_cast< SoVRMLTransform * >(argp2);
  (arg1)->combineRight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_setMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    arg2 = new SbMatrix();
  }
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_setMatrix" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  (arg1)->setMatrix((SbMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    resultobj = SWIG_NewPointerObj((void *) arg2, SWIGTYPE_p_SbMatrix, 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_recenter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_recenter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_recenter" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_recenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoVRMLTransform_recenter" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->recenter((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_doAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_doAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_doAction" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_doAction" "', argument " "2"" of type '" "SoAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAction * >(argp2);
  (arg1)->doAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoCallbackAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_callback" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCallbackAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_callback" "', argument " "2"" of type '" "SoCallbackAction *""'"); 
  }
  arg2 = reinterpret_cast< SoCallbackAction * >(argp2);
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getBoundingBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoGetBoundingBoxAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getBoundingBox", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getBoundingBox" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetBoundingBoxAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_getBoundingBox" "', argument " "2"" of type '" "SoGetBoundingBoxAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetBoundingBoxAction * >(argp2);
  (arg1)->getBoundingBox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoGetMatrixAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getMatrix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getMatrix" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetMatrixAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_getMatrix" "', argument " "2"" of type '" "SoGetMatrixAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetMatrixAction * >(argp2);
  (arg1)->getMatrix(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_rayPick(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoRayPickAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_rayPick", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_rayPick" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRayPickAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_rayPick" "', argument " "2"" of type '" "SoRayPickAction *""'"); 
  }
  arg2 = reinterpret_cast< SoRayPickAction * >(argp2);
  (arg1)->rayPick(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_getPrimitiveCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoGetPrimitiveCountAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_getPrimitiveCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_getPrimitiveCount" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGetPrimitiveCountAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_getPrimitiveCount" "', argument " "2"" of type '" "SoGetPrimitiveCountAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGetPrimitiveCountAction * >(argp2);
  (arg1)->getPrimitiveCount(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_audioRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoAudioRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_audioRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_audioRender" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_audioRender" "', argument " "2"" of type '" "SoAudioRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->audioRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_GLRenderBelowPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_GLRenderBelowPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_GLRenderBelowPath" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_GLRenderBelowPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderBelowPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_GLRenderInPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_GLRenderInPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_GLRenderInPath" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_GLRenderInPath" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRenderInPath(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLTransform_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLTransform *arg1 = 0 ;
  SoNotList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLTransform_notify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLTransform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLTransform_notify" "', argument " "1"" of type '" "SoVRMLTransform *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLTransform * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNotList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLTransform_notify" "', argument " "2"" of type '" "SoNotList *""'"); 
  }
  arg2 = reinterpret_cast< SoNotList * >(argp2);
  (arg1)->notify(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLTransform, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLTransform_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLViewpoint::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_getTypeId" "', argument " "1"" of type '" "SoVRMLViewpoint const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = ((SoVRMLViewpoint const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLViewpoint::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLViewpoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLViewpoint", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLViewpoint *)new SoVRMLViewpoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLViewpoint, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_position_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_position_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_position_set" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_position_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_position_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_position_get" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->position);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_orientation_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoSFRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_orientation_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_orientation_set" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFRotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_orientation_set" "', argument " "2"" of type '" "SoSFRotation *""'"); 
  }
  arg2 = reinterpret_cast< SoSFRotation * >(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_orientation_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFRotation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_orientation_get" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = (SoSFRotation *)& ((arg1)->orientation);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFRotation, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_fieldOfView_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoSFFloat *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_fieldOfView_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_fieldOfView_set" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFFloat, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_fieldOfView_set" "', argument " "2"" of type '" "SoSFFloat *""'"); 
  }
  arg2 = reinterpret_cast< SoSFFloat * >(argp2);
  if (arg1) (arg1)->fieldOfView = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_fieldOfView_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFFloat *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_fieldOfView_get" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = (SoSFFloat *)& ((arg1)->fieldOfView);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFFloat, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_description_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_description_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_description_set" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_description_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->description = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_description_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_description_get" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = (SoSFString *)& ((arg1)->description);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_jump_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_jump_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_jump_set" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_jump_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->jump = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_jump_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_jump_get" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  result = (SoSFBool *)& ((arg1)->jump);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLViewpoint_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLViewpoint *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLViewpoint_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLViewpoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLViewpoint_GLRender" "', argument " "1"" of type '" "SoVRMLViewpoint *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLViewpoint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLViewpoint_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLViewpoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLViewpoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLViewpoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLVisibilitySensor::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_getTypeId" "', argument " "1"" of type '" "SoVRMLVisibilitySensor const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = ((SoVRMLVisibilitySensor const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLVisibilitySensor::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLVisibilitySensor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLVisibilitySensor", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLVisibilitySensor *)new SoVRMLVisibilitySensor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLVisibilitySensor, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_center_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_center_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_center_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_center_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->center = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_center_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_center_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->center);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_size_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_size_set" "', argument " "2"" of type '" "SoSFVec3f *""'"); 
  }
  arg2 = reinterpret_cast< SoSFVec3f * >(argp2);
  if (arg1) (arg1)->size = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFVec3f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_size_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFVec3f *)& ((arg1)->size);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_enabled_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_enabled_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_enabled_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_enabled_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->enabled = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_enabled_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_enabled_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->enabled);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_enterTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_enterTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_enterTime_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_enterTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->enterTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_enterTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_enterTime_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->enterTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_exitTime_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFTime *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_exitTime_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_exitTime_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_exitTime_set" "', argument " "2"" of type '" "SoSFTime *""'"); 
  }
  arg2 = reinterpret_cast< SoSFTime * >(argp2);
  if (arg1) (arg1)->exitTime = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_exitTime_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFTime *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_exitTime_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFTime *)& ((arg1)->exitTime);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFTime, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_isActive_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoSFBool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_isActive_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_isActive_set" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFBool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_isActive_set" "', argument " "2"" of type '" "SoSFBool *""'"); 
  }
  arg2 = reinterpret_cast< SoSFBool * >(argp2);
  if (arg1) (arg1)->isActive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_isActive_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFBool *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_isActive_get" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  result = (SoSFBool *)& ((arg1)->isActive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFBool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLVisibilitySensor_GLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLVisibilitySensor *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLVisibilitySensor_GLRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLVisibilitySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLVisibilitySensor_GLRender" "', argument " "1"" of type '" "SoVRMLVisibilitySensor *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLVisibilitySensor * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLVisibilitySensor_GLRender" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->GLRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLVisibilitySensor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLVisibilitySensor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLVisibilitySensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLWorldInfo_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoVRMLWorldInfo::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLWorldInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLWorldInfo_getTypeId" "', argument " "1"" of type '" "SoVRMLWorldInfo const *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLWorldInfo * >(argp1);
  result = ((SoVRMLWorldInfo const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLWorldInfo_initClass", 0, 0, 0)) SWIG_fail;
  SoVRMLWorldInfo::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoVRMLWorldInfo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoVRMLWorldInfo", 0, 0, 0)) SWIG_fail;
  result = (SoVRMLWorldInfo *)new SoVRMLWorldInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoVRMLWorldInfo, SWIG_POINTER_NEW |  0 );
  result->ref();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_title_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *arg1 = 0 ;
  SoSFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLWorldInfo_title_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLWorldInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLWorldInfo_title_set" "', argument " "1"" of type '" "SoVRMLWorldInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLWorldInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLWorldInfo_title_set" "', argument " "2"" of type '" "SoSFString *""'"); 
  }
  arg2 = reinterpret_cast< SoSFString * >(argp2);
  if (arg1) (arg1)->title = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_title_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLWorldInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLWorldInfo_title_get" "', argument " "1"" of type '" "SoVRMLWorldInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLWorldInfo * >(argp1);
  result = (SoSFString *)& ((arg1)->title);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_info_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *arg1 = 0 ;
  SoMFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoVRMLWorldInfo_info_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLWorldInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLWorldInfo_info_set" "', argument " "1"" of type '" "SoVRMLWorldInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLWorldInfo * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoMFString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoVRMLWorldInfo_info_set" "', argument " "2"" of type '" "SoMFString *""'"); 
  }
  arg2 = reinterpret_cast< SoMFString * >(argp2);
  if (arg1) (arg1)->info = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoVRMLWorldInfo_info_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoVRMLWorldInfo *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoMFString *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoVRMLWorldInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoVRMLWorldInfo_info_get" "', argument " "1"" of type '" "SoVRMLWorldInfo *""'"); 
  }
  arg1 = reinterpret_cast< SoVRMLWorldInfo * >(argp1);
  result = (SoMFString *)& ((arg1)->info);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoMFString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoVRMLWorldInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoVRMLWorldInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoVRMLWorldInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoEventManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoEventManager", 0, 0, 0)) SWIG_fail;
  result = (SoEventManager *)new SoEventManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoEventManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoEventManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoEventManager" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setSceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setSceneGraph" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setSceneGraph" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getSceneGraph" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (SoNode *)((SoEventManager const *)arg1)->getSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoCamera *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setCamera" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setCamera" "', argument " "2"" of type '" "SoCamera *""'"); 
  }
  arg2 = reinterpret_cast< SoCamera * >(argp2);
  (arg1)->setCamera(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCamera *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getCamera" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (SoCamera *)((SoEventManager const *)arg1)->getCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_processEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoEvent *arg2 = (SoEvent *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_processEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_processEvent" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_processEvent" "', argument " "2"" of type '" "SoEvent const *const""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  result = (SbBool)(arg1)->processEvent((SoEvent const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setNavigationState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoEventManager::NavigationState arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setNavigationState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setNavigationState" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEventManager_setNavigationState" "', argument " "2"" of type '" "SoEventManager::NavigationState""'");
  } 
  arg2 = static_cast< SoEventManager::NavigationState >(val2);
  (arg1)->setNavigationState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getNavigationState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEventManager::NavigationState result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getNavigationState" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (SoEventManager::NavigationState)((SoEventManager const *)arg1)->getNavigationState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getNumSoScXMLStateMachines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getNumSoScXMLStateMachines" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (int)((SoEventManager const *)arg1)->getNumSoScXMLStateMachines();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getSoScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SoScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_getSoScXMLStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getSoScXMLStateMachine" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoEventManager_getSoScXMLStateMachine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SoScXMLStateMachine *)((SoEventManager const *)arg1)->getSoScXMLStateMachine(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_addSoScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_addSoScXMLStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_addSoScXMLStateMachine" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_addSoScXMLStateMachine" "', argument " "2"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< SoScXMLStateMachine * >(argp2);
  (arg1)->addSoScXMLStateMachine(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_removeSoScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_removeSoScXMLStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_removeSoScXMLStateMachine" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_removeSoScXMLStateMachine" "', argument " "2"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< SoScXMLStateMachine * >(argp2);
  (arg1)->removeSoScXMLStateMachine(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setSize" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setSize((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setOrigin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setOrigin" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setOrigin((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setViewportRegion" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoEventManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getViewportRegion" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (SbViewportRegion *) &((SoEventManager const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_setHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  SoHandleEventAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoEventManager_setHandleEventAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_setHandleEventAction" "', argument " "1"" of type '" "SoEventManager *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoEventManager_setHandleEventAction" "', argument " "2"" of type '" "SoHandleEventAction *""'"); 
  }
  arg2 = reinterpret_cast< SoHandleEventAction * >(argp2);
  (arg1)->setHandleEventAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoEventManager_getHandleEventAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoEventManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoHandleEventAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoEventManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoEventManager_getHandleEventAction" "', argument " "1"" of type '" "SoEventManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoEventManager * >(argp1);
  result = (SoHandleEventAction *)((SoEventManager const *)arg1)->getHandleEventAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoHandleEventAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoEventManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoEventManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoEventManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoRenderManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoRenderManager", 0, 0, 0)) SWIG_fail;
  result = (SoRenderManager *)new SoRenderManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRenderManager, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoRenderManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoRenderManager" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->render(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  (arg1)->render();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  SbBool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoRenderManager_render" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoRenderManager_render" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  (arg1)->render(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoRenderManager_render" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  (arg1)->render(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_render" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->render(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_render" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_render" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->render(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_render(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_render", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SoRenderManager_render__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRenderManager_render__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoRenderManager_render__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoRenderManager_render__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoRenderManager_render__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoRenderManager_render__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoGLRenderAction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoRenderManager_render__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_render'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::render(SbBool const,SbBool const)\n"
    "    SoRenderManager::render(SbBool const)\n"
    "    SoRenderManager::render()\n"
    "    SoRenderManager::render(SoGLRenderAction *,SbBool const,SbBool const,SbBool const)\n"
    "    SoRenderManager::render(SoGLRenderAction *,SbBool const,SbBool const)\n"
    "    SoRenderManager::render(SoGLRenderAction *,SbBool const)\n"
    "    SoRenderManager::render(SoGLRenderAction *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addSuperimposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  SoRenderManager::Superimposition *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addSuperimposition" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_addSuperimposition" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_addSuperimposition" "', argument " "3"" of type '" "uint32_t""'");
  } 
  arg3 = static_cast< uint32_t >(val3);
  result = (SoRenderManager::Superimposition *)(arg1)->addSuperimposition(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRenderManager__Superimposition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addSuperimposition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SoRenderManager::Superimposition *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addSuperimposition" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_addSuperimposition" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  result = (SoRenderManager::Superimposition *)(arg1)->addSuperimposition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoRenderManager__Superimposition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addSuperimposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_addSuperimposition", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRenderManager_addSuperimposition__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SoNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoRenderManager_addSuperimposition__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_addSuperimposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::addSuperimposition(SoNode *,uint32_t)\n"
    "    SoRenderManager::addSuperimposition(SoNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removeSuperimposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManager::Superimposition *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_removeSuperimposition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_removeSuperimposition" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoRenderManager__Superimposition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_removeSuperimposition" "', argument " "2"" of type '" "SoRenderManager::Superimposition *""'"); 
  }
  arg2 = reinterpret_cast< SoRenderManager::Superimposition * >(argp2);
  (arg1)->removeSuperimposition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoNode *arg2 = (SoNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setSceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setSceneGraph" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setSceneGraph" "', argument " "2"" of type '" "SoNode *const""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getSceneGraph" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoNode *)((SoRenderManager const *)arg1)->getSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoCamera *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setCamera" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setCamera" "', argument " "2"" of type '" "SoCamera *""'"); 
  }
  arg2 = reinterpret_cast< SoCamera * >(argp2);
  (arg1)->setCamera(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCamera *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getCamera" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoCamera *)((SoRenderManager const *)arg1)->getCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setAutoClipping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManager::AutoClippingStrategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setAutoClipping", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setAutoClipping" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setAutoClipping" "', argument " "2"" of type '" "SoRenderManager::AutoClippingStrategy""'");
  } 
  arg2 = static_cast< SoRenderManager::AutoClippingStrategy >(val2);
  (arg1)->setAutoClipping(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getAutoClipping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoRenderManager::AutoClippingStrategy result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getAutoClipping" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoRenderManager::AutoClippingStrategy)((SoRenderManager const *)arg1)->getAutoClipping();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setNearPlaneValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setNearPlaneValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setNearPlaneValue" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setNearPlaneValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setNearPlaneValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getNearPlaneValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getNearPlaneValue" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (float)((SoRenderManager const *)arg1)->getNearPlaneValue();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setTexturesEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setTexturesEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setTexturesEnabled" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setTexturesEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setTexturesEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_isTexturesEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_isTexturesEnabled" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbBool)((SoRenderManager const *)arg1)->isTexturesEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setDoubleBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setDoubleBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setDoubleBuffer" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setDoubleBuffer" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDoubleBuffer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_isDoubleBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_isDoubleBuffer" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbBool)((SoRenderManager const *)arg1)->isDoubleBuffer();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManager::RenderMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setRenderMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRenderMode" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setRenderMode" "', argument " "2"" of type '" "SoRenderManager::RenderMode""'");
  } 
  arg2 = static_cast< SoRenderManager::RenderMode >(val2);
  (arg1)->setRenderMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getRenderMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoRenderManager::RenderMode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getRenderMode" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoRenderManager::RenderMode)((SoRenderManager const *)arg1)->getRenderMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setStereoMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManager::StereoMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setStereoMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setStereoMode" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setStereoMode" "', argument " "2"" of type '" "SoRenderManager::StereoMode""'");
  } 
  arg2 = static_cast< SoRenderManager::StereoMode >(val2);
  (arg1)->setStereoMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getStereoMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoRenderManager::StereoMode result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getStereoMode" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoRenderManager::StereoMode)((SoRenderManager const *)arg1)->getStereoMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setStereoOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setStereoOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setStereoOffset" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setStereoOffset" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setStereoOffset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getStereoOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getStereoOffset" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (float)((SoRenderManager const *)arg1)->getStereoOffset();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *arg3 = (void *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_setRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRenderManager_setRenderCallback" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_setRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  (arg1)->setRenderCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_isAutoRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_isAutoRedraw" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbBool)((SoRenderManager const *)arg1)->isAutoRedraw();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setRedrawPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRedrawPriority" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setRedrawPriority" "', argument " "2"" of type '" "uint32_t""'");
  } 
  arg2 = static_cast< uint32_t >(val2);
  (arg1)->setRedrawPriority(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uint32_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getRedrawPriority" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (uint32_t)((SoRenderManager const *)arg1)->getRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_scheduleRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_scheduleRedraw" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  (arg1)->scheduleRedraw();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setWindowSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setWindowSize" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setWindowSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setWindowSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setWindowSize((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getWindowSize" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbVec2s *) &((SoRenderManager const *)arg1)->getWindowSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setSize" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setSize" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setSize((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getSize" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbVec2s *) &((SoRenderManager const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbVec2s *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setOrigin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setOrigin" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setOrigin" "', argument " "2"" of type '" "SbVec2s const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2s * >(argp2);
  (arg1)->setOrigin((SbVec2s const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getOrigin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getOrigin" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbVec2s *) &((SoRenderManager const *)arg1)->getOrigin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec2s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setViewportRegion" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getViewportRegion" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbViewportRegion *) &((SoRenderManager const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setBackgroundColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setBackgroundColor" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setBackgroundColor" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setBackgroundColor" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  (arg1)->setBackgroundColor((SbColor4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor4f *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getBackgroundColor" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbColor4f *) &((SoRenderManager const *)arg1)->getBackgroundColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor4f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setOverlayColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbColor4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setOverlayColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setOverlayColor" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbColor4f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setOverlayColor" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_setOverlayColor" "', argument " "2"" of type '" "SbColor4f const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor4f * >(argp2);
  (arg1)->setOverlayColor((SbColor4f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getOverlayColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbColor4f result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getOverlayColor" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = ((SoRenderManager const *)arg1)->getOverlayColor();
  resultobj = SWIG_NewPointerObj((new SbColor4f(result)), SWIGTYPE_p_SbColor4f, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setBackgroundIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setBackgroundIndex" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setBackgroundIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setBackgroundIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getBackgroundIndex" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (int)((SoRenderManager const *)arg1)->getBackgroundIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRGBMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setRGBMode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRGBMode" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setRGBMode" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setRGBMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_isRGBMode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_isRGBMode" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SbBool)((SoRenderManager const *)arg1)->isRGBMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_activate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_activate" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  (arg1)->activate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_deactivate" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setAntialiasing" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoRenderManager_setAntialiasing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoRenderManager_setAntialiasing" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setAntialiasing(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SbBool *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_getAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getAntialiasing" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_getAntialiasing" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_getAntialiasing" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoRenderManager_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoRenderManager_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ((SoRenderManager const *)arg1)->getAntialiasing(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoGLRenderAction *arg2 = (SoGLRenderAction *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setGLRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setGLRenderAction" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setGLRenderAction" "', argument " "2"" of type '" "SoGLRenderAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->setGLRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoGLRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getGLRenderAction" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoGLRenderAction *)((SoRenderManager const *)arg1)->getGLRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoAudioRenderAction *arg2 = (SoAudioRenderAction *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_setAudioRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setAudioRenderAction" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoRenderManager_setAudioRenderAction" "', argument " "2"" of type '" "SoAudioRenderAction *const""'"); 
  }
  arg2 = reinterpret_cast< SoAudioRenderAction * >(argp2);
  (arg1)->setAudioRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getAudioRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoAudioRenderAction *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_getAudioRenderAction" "', argument " "1"" of type '" "SoRenderManager const *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  result = (SoAudioRenderAction *)((SoRenderManager const *)arg1)->getAudioRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoAudioRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_enableRealTimeUpdate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SoRenderManager_enableRealTimeUpdate" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  SoRenderManager::enableRealTimeUpdate(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_isRealTimeUpdateEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_isRealTimeUpdateEnabled", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoRenderManager::isRealTimeUpdateEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_getDefaultRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoRenderManager_getDefaultRedrawPriority", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoRenderManager::getDefaultRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPreRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addPreRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_addPreRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addPreRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePreRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_removePreRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_removePreRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removePreRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPostRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addPostRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_addPostRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->addPostRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePostRenderCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  SoRenderManagerRenderCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_removePostRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoRenderManager_removePostRenderCallback" "', argument " "2"" of type '" "SoRenderManagerRenderCB *""'"); 
    }
  }
  {
    if (!PyTuple_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "tuple expected!");
      return NULL;
    }
    
    Py_INCREF(swig_obj[2]);
    arg3 = (void *)swig_obj[2];
  }
  (arg1)->removePostRenderCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_reinitialize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_reinitialize" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  (arg1)->reinitialize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoRenderManager_setRenderCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_setRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoRenderManager_setRenderCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_setRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_setRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoRenderManager_setRenderCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoRenderManager_setRenderCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoRenderManager_setRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoRenderManager_setRenderCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_setRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::setRenderCallback(SoRenderManagerRenderCB *,void *const)\n"
    "    SoRenderManager::setRenderCallback(SoRenderManagerRenderCB *)\n"
    "    SoRenderManager::setRenderCallback(PyObject *,PyObject *)\n"
    "    SoRenderManager::setRenderCallback(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPreRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addPreRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoRenderManager_addPreRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPreRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_addPreRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoRenderManager_addPreRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoRenderManager_addPreRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_addPreRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::addPreRenderCallback(SoRenderManagerRenderCB *,void *)\n"
    "    SoRenderManager::addPreRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePreRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_removePreRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoRenderManager_removePreRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePreRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_removePreRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoRenderManager_removePreRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoRenderManager_removePreRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_removePreRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::removePreRenderCallback(SoRenderManagerRenderCB *,void *)\n"
    "    SoRenderManager::removePreRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPostRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_addPostRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoRenderManager_addPostRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_addPostRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_addPostRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoRenderManager_addPostRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoRenderManager_addPostRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_addPostRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::addPostRenderCallback(SoRenderManagerRenderCB *,void *)\n"
    "    SoRenderManager::addPostRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePostRenderCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoRenderManager *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoRenderManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoRenderManager_removePostRenderCallback" "', argument " "1"" of type '" "SoRenderManager *""'"); 
  }
  arg1 = reinterpret_cast< SoRenderManager * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  SoRenderManager_removePostRenderCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoRenderManager_removePostRenderCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoRenderManager_removePostRenderCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoRenderManager__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoRenderManager_removePostRenderCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoRenderManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoRenderManager_removePostRenderCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoRenderManager_removePostRenderCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoRenderManager::removePostRenderCallback(SoRenderManagerRenderCB *,void *)\n"
    "    SoRenderManager::removePostRenderCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *SoRenderManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoRenderManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoRenderManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLObject_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLObject_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLObject::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLObject_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLObject_getTypeId" "', argument " "1"" of type '" "ScXMLObject const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLObject * >(argp1);
  result = ((ScXMLObject const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLObject_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLObject_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLObject::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLObject_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLObject_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLObject::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLObject" "', argument " "1"" of type '" "ScXMLObject *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLObject * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLObject_isOfType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLObject *arg1 = 0 ;
  SoType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLObject_isOfType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLObject_isOfType" "', argument " "1"" of type '" "ScXMLObject const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLObject * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLObject_isOfType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXMLObject_isOfType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)((ScXMLObject const *)arg1)->isOfType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLEventTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLEventTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_getTypeId" "', argument " "1"" of type '" "ScXMLEventTarget const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  result = ((ScXMLEventTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLEventTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLEventTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLEventTarget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEventTarget" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_setEventTargetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_setEventTargetType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_setEventTargetType" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_setEventTargetType" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setEventTargetType((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_getEventTargetType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_getEventTargetType" "', argument " "1"" of type '" "ScXMLEventTarget const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  result = (char *)((ScXMLEventTarget const *)arg1)->getEventTargetType();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_setEventTargetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_setEventTargetName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_setEventTargetName" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_setEventTargetName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setEventTargetName((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_getEventTargetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_getEventTargetName" "', argument " "1"" of type '" "ScXMLEventTarget const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  result = (char *)((ScXMLEventTarget const *)arg1)->getEventTargetName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_getCurrentEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_getCurrentEvent" "', argument " "1"" of type '" "ScXMLEventTarget const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  result = (ScXMLEvent *)((ScXMLEventTarget const *)arg1)->getCurrentEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  ScXMLEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_queueEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_queueEvent" "', argument " "2"" of type '" "ScXMLEvent const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEvent * >(argp2);
  (arg1)->queueEvent((ScXMLEvent const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_queueEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->queueEvent((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_queueEvent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLEventTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ScXMLEventTarget_queueEvent__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLEventTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_ScXMLEventTarget_queueEvent__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLEventTarget_queueEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLEventTarget::queueEvent(ScXMLEvent const *)\n"
    "    ScXMLEventTarget::queueEvent(SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_processEventQueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_processEventQueue" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  result = (SbBool)(arg1)->processEventQueue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_sendExternalEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  ScXMLSendElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_sendExternalEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_sendExternalEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_sendExternalEvent" "', argument " "2"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLSendElt * >(argp2);
  result = (SbBool)(arg1)->sendExternalEvent((ScXMLSendElt const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_sendInternalEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  ScXMLEventElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_sendInternalEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_sendInternalEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_sendInternalEvent" "', argument " "2"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEventElt * >(argp2);
  result = (SbBool)(arg1)->sendInternalEvent((ScXMLEventElt const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueInternalEvent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  ScXMLEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_queueInternalEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventTarget_queueInternalEvent" "', argument " "2"" of type '" "ScXMLEvent const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEvent * >(argp2);
  (arg1)->queueInternalEvent((ScXMLEvent const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueInternalEvent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLEventTarget *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventTarget_queueInternalEvent" "', argument " "1"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventTarget * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->queueInternalEvent((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventTarget_queueInternalEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLEventTarget_queueInternalEvent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLEventTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ScXMLEventTarget_queueInternalEvent__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLEventTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        void *ptr = NULL;
        _v = 1;
        
        
        
        
        if (!PyBytes_Check(argv[1]) && 
          !PyUnicode_Check(argv[1]) && 
          (SWIG_ConvertPtr(argv[1], (void**)(&ptr), SWIGTYPE_p_SbName, 0) == -1))
        
        {
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_ScXMLEventTarget_queueInternalEvent__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLEventTarget_queueInternalEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLEventTarget::queueInternalEvent(ScXMLEvent const *)\n"
    "    ScXMLEventTarget::queueInternalEvent(SbName const &)\n");
  return 0;
}


SWIGINTERN PyObject *ScXMLEventTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEventTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLNavigationTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigationTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLNavigationTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigationTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLNavigationTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLNavigationTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLNavigationTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLNavigationTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLNavigationTarget * >(argp1);
  result = ((SoScXMLNavigationTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigationTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigationTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigationTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigationTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigationTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigationTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLNavigationTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLNavigationTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLDollyTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLDollyTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLDollyTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLDollyTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLDollyTarget * >(argp1);
  result = ((SoScXMLDollyTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLDollyTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLDollyTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLDollyTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLDollyTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLDollyTarget *)SoScXMLDollyTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLDollyTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLDollyTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLDollyTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLDollyTarget *)SoScXMLDollyTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLDollyTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_JUMP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_JUMP", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::JUMP();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_STEP_IN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_STEP_IN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::STEP_IN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_STEP_OUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_STEP_OUT", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLDollyTarget::STEP_OUT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_dolly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_dolly", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_dolly" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLDollyTarget_dolly" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLDollyTarget::dolly(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_jump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_jump", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_jump" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLDollyTarget_jump" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLDollyTarget::jump(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbBool arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_step" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLDollyTarget_step" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoScXMLDollyTarget_step" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoScXMLDollyTarget_step" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SoScXMLDollyTarget_step" "', argument " "5"" of type '" "float""'");
  } 
  arg5 = static_cast< float >(val5);
  SoScXMLDollyTarget::step(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbBool arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_step" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLDollyTarget_step" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoScXMLDollyTarget_step" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SoScXMLDollyTarget_step" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  SoScXMLDollyTarget::step(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_step__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbBool arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLDollyTarget_step" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLDollyTarget_step" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoScXMLDollyTarget_step" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  SoScXMLDollyTarget::step(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLDollyTarget_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoScXMLDollyTarget_step", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoScXMLDollyTarget_step__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SoScXMLDollyTarget_step__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SoScXMLDollyTarget_step__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoScXMLDollyTarget_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoScXMLDollyTarget::step(SoCamera *,SbBool,float,float,float)\n"
    "    SoScXMLDollyTarget::step(SoCamera *,SbBool,float,float)\n"
    "    SoScXMLDollyTarget::step(SoCamera *,SbBool,float)\n");
  return 0;
}


SWIGINTERN PyObject *SoScXMLDollyTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLDollyTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLFlightControlTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLFlightControlTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLFlightControlTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLFlightControlTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLFlightControlTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLFlightControlTarget * >(argp1);
  result = ((SoScXMLFlightControlTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLFlightControlTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLFlightControlTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLFlightControlTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLFlightControlTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLFlightControlTarget *)SoScXMLFlightControlTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLFlightControlTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLFlightControlTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLFlightControlTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLFlightControlTarget *)SoScXMLFlightControlTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLFlightControlTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_PITCH(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_PITCH", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLFlightControlTarget::PITCH();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_YAW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_YAW", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLFlightControlTarget::YAW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_ROLL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_ROLL", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLFlightControlTarget::ROLL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_RESET_ROLL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_RESET_ROLL", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLFlightControlTarget::RESET_ROLL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_pitch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_pitch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLFlightControlTarget_pitch" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLFlightControlTarget_pitch" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLFlightControlTarget::pitch(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_yaw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_yaw", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLFlightControlTarget_yaw" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLFlightControlTarget_yaw" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLFlightControlTarget::yaw(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_roll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_roll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLFlightControlTarget_roll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLFlightControlTarget_roll" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLFlightControlTarget::roll(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLFlightControlTarget_resetRoll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLFlightControlTarget_resetRoll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLFlightControlTarget_resetRoll" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLFlightControlTarget_resetRoll" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLFlightControlTarget_resetRoll" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoScXMLFlightControlTarget::resetRoll(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLFlightControlTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLFlightControlTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLMiscTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMiscTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLMiscTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLMiscTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLMiscTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLMiscTarget * >(argp1);
  result = ((SoScXMLMiscTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLMiscTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLMiscTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLMiscTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMiscTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLMiscTarget *)SoScXMLMiscTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLMiscTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLMiscTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMiscTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLMiscTarget *)SoScXMLMiscTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLMiscTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_VIEW_ALL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_VIEW_ALL", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLMiscTarget::VIEW_ALL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_REDRAW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_REDRAW", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLMiscTarget::REDRAW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_POINT_AT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_POINT_AT", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLMiscTarget::POINT_AT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_SET_FOCAL_DISTANCE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_SET_FOCAL_DISTANCE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLMiscTarget::SET_FOCAL_DISTANCE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMiscTarget_SET_CAMERA_POSITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMiscTarget_SET_CAMERA_POSITION", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLMiscTarget::SET_CAMERA_POSITION();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLMiscTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLMiscTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLMotionTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMotionTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLMotionTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLMotionTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLMotionTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLMotionTarget * >(argp1);
  result = ((SoScXMLMotionTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLMotionTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLMotionTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLMotionTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMotionTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLMotionTarget *)SoScXMLMotionTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLMotionTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLMotionTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLMotionTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLMotionTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLMotionTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLMotionTarget *)SoScXMLMotionTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLMotionTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLMotionTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLMotionTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLNavigation_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigation_initClasses", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigation::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigation_cleanClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigation_cleanClasses", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigation::cleanClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigation_syncLock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigation_syncLock", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigation::syncLock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLNavigation_syncUnlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLNavigation_syncUnlock", 0, 0, 0)) SWIG_fail;
  SoScXMLNavigation::syncUnlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScXMLNavigation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLNavigation *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScXMLNavigation", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLNavigation *)new SoScXMLNavigation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLNavigation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoScXMLNavigation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLNavigation *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLNavigation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoScXMLNavigation" "', argument " "1"" of type '" "SoScXMLNavigation *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLNavigation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLNavigation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLNavigation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScXMLNavigation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLPanTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLPanTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLPanTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLPanTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLPanTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLPanTarget * >(argp1);
  result = ((SoScXMLPanTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLPanTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLPanTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLPanTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLPanTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLPanTarget *)SoScXMLPanTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLPanTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLPanTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLPanTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLPanTarget *)SoScXMLPanTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLPanTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLPanTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLPanTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLPanTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_SET_FOCAL_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_SET_FOCAL_POINT", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLPanTarget::SET_FOCAL_POINT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_MOVE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_MOVE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLPanTarget::MOVE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_panCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  SbPlane *arg3 = 0 ;
  SbVec2f *arg4 = 0 ;
  SbVec2f *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_panCamera", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLPanTarget_panCamera" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLPanTarget_panCamera" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbPlane,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoScXMLPanTarget_panCamera" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_panCamera" "', argument " "3"" of type '" "SbPlane const &""'"); 
  }
  arg3 = reinterpret_cast< SbPlane * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoScXMLPanTarget_panCamera" "', argument " "4"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_panCamera" "', argument " "4"" of type '" "SbVec2f const &""'"); 
  }
  arg4 = reinterpret_cast< SbVec2f * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SbVec2f,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoScXMLPanTarget_panCamera" "', argument " "5"" of type '" "SbVec2f const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_panCamera" "', argument " "5"" of type '" "SbVec2f const &""'"); 
  }
  arg5 = reinterpret_cast< SbVec2f * >(argp5);
  SoScXMLPanTarget::panCamera(arg1,arg2,(SbPlane const &)*arg3,(SbVec2f const &)*arg4,(SbVec2f const &)*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_panSetFocalPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_panSetFocalPoint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLPanTarget_panSetFocalPoint" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLPanTarget_panSetFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_panSetFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoScXMLPanTarget::panSetFocalPoint(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_translateCamera__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbBool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  SoScXMLPanTarget::translateCamera(arg1,(SbVec3f const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_translateCamera__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLPanTarget_translateCamera" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoScXMLPanTarget::translateCamera(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLPanTarget_translateCamera(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoScXMLPanTarget_translateCamera", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoScXMLPanTarget_translateCamera__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SoScXMLPanTarget_translateCamera__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoScXMLPanTarget_translateCamera'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoScXMLPanTarget::translateCamera(SoCamera *,SbVec3f const &,SbBool)\n"
    "    SoScXMLPanTarget::translateCamera(SoCamera *,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *SoScXMLPanTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLPanTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLRotateTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLRotateTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLRotateTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLRotateTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLRotateTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLRotateTarget * >(argp1);
  result = ((SoScXMLRotateTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLRotateTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLRotateTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLRotateTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLRotateTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLRotateTarget *)SoScXMLRotateTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLRotateTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLRotateTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLRotateTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLRotateTarget *)SoScXMLRotateTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLRotateTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLRotateTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLRotateTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLRotateTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_SET_FOCAL_POINT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_SET_FOCAL_POINT", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLRotateTarget::SET_FOCAL_POINT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_setFocalPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  SoScXMLRotateTarget::setFocalPoint(arg1,(SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_setFocalPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbVec3f *arg2 = 0 ;
  SbVec3f *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SbVec3f,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLRotateTarget_setFocalPoint" "', argument " "3"" of type '" "SbVec3f const &""'"); 
  }
  arg3 = reinterpret_cast< SbVec3f * >(argp3);
  SoScXMLRotateTarget::setFocalPoint(arg1,(SbVec3f const &)*arg2,(SbVec3f const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_setFocalPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_setFocalPoint", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoScXMLRotateTarget_setFocalPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoCamera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SbVec3f, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoScXMLRotateTarget_setFocalPoint__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoScXMLRotateTarget_setFocalPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoScXMLRotateTarget::setFocalPoint(SoCamera *,SbVec3f const &)\n"
    "    SoScXMLRotateTarget::setFocalPoint(SoCamera *,SbVec3f const &,SbVec3f const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoScXMLRotateTarget_reorientCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLRotateTarget_reorientCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLRotateTarget_reorientCamera" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLRotateTarget_reorientCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLRotateTarget_reorientCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  SoScXMLRotateTarget::reorientCamera(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLRotateTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLRotateTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLSeekTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSeekTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLSeekTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLSeekTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLSeekTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLSeekTarget * >(argp1);
  result = ((SoScXMLSeekTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLSeekTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLSeekTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLSeekTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSeekTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLSeekTarget *)SoScXMLSeekTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLSeekTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLSeekTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSeekTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLSeekTarget *)SoScXMLSeekTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLSeekTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSeekTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSeekTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSeekTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSeekTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSeekTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLSeekTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLSeekTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLSpinTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSpinTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLSpinTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLSpinTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLSpinTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLSpinTarget * >(argp1);
  result = ((SoScXMLSpinTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLSpinTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLSpinTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLSpinTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSpinTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLSpinTarget *)SoScXMLSpinTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLSpinTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLSpinTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLSpinTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLSpinTarget *)SoScXMLSpinTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLSpinTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSpinTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSpinTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLSpinTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLSpinTarget_reorientCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  SbRotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLSpinTarget_reorientCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLSpinTarget_reorientCamera" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbRotation,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLSpinTarget_reorientCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLSpinTarget_reorientCamera" "', argument " "2"" of type '" "SbRotation const &""'"); 
  }
  arg2 = reinterpret_cast< SbRotation * >(argp2);
  SoScXMLSpinTarget::reorientCamera(arg1,(SbRotation const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLSpinTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLSpinTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLZoomTarget::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLZoomTarget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLZoomTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLZoomTarget_getTypeId" "', argument " "1"" of type '" "SoScXMLZoomTarget const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLZoomTarget * >(argp1);
  result = ((SoScXMLZoomTarget const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLZoomTarget::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLZoomTarget::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLZoomTarget::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_constructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLZoomTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_constructSingleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLZoomTarget *)SoScXMLZoomTarget::constructSingleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLZoomTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_destructSingleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_destructSingleton", 0, 0, 0)) SWIG_fail;
  SoScXMLZoomTarget::destructSingleton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLZoomTarget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_singleton", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLZoomTarget *)SoScXMLZoomTarget::singleton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLZoomTarget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_BEGIN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_BEGIN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::BEGIN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_UPDATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_UPDATE", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::UPDATE();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_END(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_END", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::END();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_ZOOM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_ZOOM", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::ZOOM();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_ZOOM_IN(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_ZOOM_IN", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::ZOOM_IN();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_ZOOM_OUT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_ZOOM_OUT", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::ZOOM_OUT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_RESET(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_RESET", 0, 0, 0)) SWIG_fail;
  result = (SbName *) &SoScXMLZoomTarget::RESET();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_zoom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLZoomTarget_zoom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLZoomTarget_zoom" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoScXMLZoomTarget_zoom" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  SoScXMLZoomTarget::zoom(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLZoomTarget_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoCamera *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLZoomTarget_reset" "', argument " "1"" of type '" "SoCamera *""'"); 
  }
  arg1 = reinterpret_cast< SoCamera * >(argp1);
  SoScXMLZoomTarget::reset(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLZoomTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLZoomTarget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXML_initClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXML_initClasses", 0, 0, 0)) SWIG_fail;
  ScXML::initClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_cleanClasses(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXML_cleanClasses", 0, 0, 0)) SWIG_fail;
  ScXML::cleanClasses();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_readFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXML_readFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLStateMachine *)ScXML::readFile((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_readBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXML_readBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXML_readBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (ScXMLStateMachine *)ScXML::readBuffer((SbByteBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_registerEvaluatorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  SoType arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXML_registerEvaluatorType", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXML_registerEvaluatorType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXML_registerEvaluatorType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)ScXML::registerEvaluatorType(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_unregisterEvaluatorType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  SoType arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXML_unregisterEvaluatorType", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoType,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXML_unregisterEvaluatorType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXML_unregisterEvaluatorType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (SbBool)ScXML::unregisterEvaluatorType(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXML_getEvaluatorTypeForProfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName arg1 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg1 = *namePtr;
    }
  }
  result = ScXML::getEvaluatorTypeForProfile(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXML *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXML", 0, 0, 0)) SWIG_fail;
  result = (ScXML *)new ScXML();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXML *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXML, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXML" "', argument " "1"" of type '" "ScXML *""'"); 
  }
  arg1 = reinterpret_cast< ScXML * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXML_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXML, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXML_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_getTypeId" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  result = ((ScXMLElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLElt" "', argument " "1"" of type '" "ScXMLElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_setXMLAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_setXMLAttribute", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_setXMLAttribute" "', argument " "1"" of type '" "ScXMLElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_setXMLAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLElt_setXMLAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->setXMLAttribute((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_getXMLAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_getXMLAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_getXMLAttribute" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_getXMLAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (char *)((ScXMLElt const *)arg1)->getXMLAttribute((char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_search" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_clone" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  result = (ScXMLElt *)((ScXMLElt const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_copyContents" "', argument " "1"" of type '" "ScXMLElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_setContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_setContainer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_setContainer" "', argument " "1"" of type '" "ScXMLElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_setContainer" "', argument " "2"" of type '" "ScXMLElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->setContainer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_getContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_getContainer" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  result = (ScXMLElt *)((ScXMLElt const *)arg1)->getContainer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElt_isContainedIn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElt_isContainedIn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElt_isContainedIn" "', argument " "1"" of type '" "ScXMLElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElt_isContainedIn" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  result = (SbBool)((ScXMLElt const *)arg1)->isContainedIn((ScXMLElt const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_ScXMLEltReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEltReader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEltReader" "', argument " "1"" of type '" "ScXMLEltReader *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEltReader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEltReader_read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  cc_xml_elt *arg3 = 0 ;
  ScXMLDocument *arg4 = 0 ;
  ScXMLStateMachine *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEltReader_read", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEltReader_read" "', argument " "1"" of type '" "ScXMLEltReader *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEltReader * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEltReader_read" "', argument " "2"" of type '" "ScXMLElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_cc_xml_elt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLEltReader_read" "', argument " "3"" of type '" "cc_xml_elt *""'"); 
  }
  arg3 = reinterpret_cast< cc_xml_elt * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScXMLEltReader_read" "', argument " "4"" of type '" "ScXMLDocument *""'"); 
  }
  arg4 = reinterpret_cast< ScXMLDocument * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScXMLEltReader_read" "', argument " "5"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg5 = reinterpret_cast< ScXMLStateMachine * >(argp5);
  result = (ScXMLElt *)(arg1)->read(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLEltReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEltReader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAbstractStateElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_getTypeId" "', argument " "1"" of type '" "ScXMLAbstractStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  result = ((ScXMLAbstractStateElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAbstractStateElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAbstractStateElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAbstractStateElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAbstractStateElt" "', argument " "1"" of type '" "ScXMLAbstractStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_setIdAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_setIdAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_setIdAttribute" "', argument " "1"" of type '" "ScXMLAbstractStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAbstractStateElt_setIdAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setIdAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_getIdAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_getIdAttribute" "', argument " "1"" of type '" "ScXMLAbstractStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  result = (char *)((ScXMLAbstractStateElt const *)arg1)->getIdAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLAbstractStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_copyContents" "', argument " "1"" of type '" "ScXMLAbstractStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAbstractStateElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAbstractStateElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAbstractStateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAbstractStateElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAbstractStateElt_search" "', argument " "1"" of type '" "ScXMLAbstractStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAbstractStateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAbstractStateElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLAbstractStateElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLAbstractStateElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLAbstractStateElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAbstractStateElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLAnchorElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAnchorElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_getTypeId" "', argument " "1"" of type '" "ScXMLAnchorElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  result = ((ScXMLAnchorElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLAnchorElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAnchorElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAnchorElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAnchorElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLAnchorElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLAnchorElt *)new ScXMLAnchorElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAnchorElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAnchorElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAnchorElt" "', argument " "1"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_setTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_setTypeAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_setTypeAttribute" "', argument " "1"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAnchorElt_setTypeAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTypeAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_getTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_getTypeAttribute" "', argument " "1"" of type '" "ScXMLAnchorElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  result = (char *)((ScXMLAnchorElt const *)arg1)->getTypeAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_setSnapshotAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_setSnapshotAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_setSnapshotAttribute" "', argument " "1"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAnchorElt_setSnapshotAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSnapshotAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_getSnapshotAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_getSnapshotAttribute" "', argument " "1"" of type '" "ScXMLAnchorElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  result = (char *)((ScXMLAnchorElt const *)arg1)->getSnapshotAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_copyContents" "', argument " "1"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAnchorElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAnchorElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAnchorElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAnchorElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAnchorElt_search" "', argument " "1"" of type '" "ScXMLAnchorElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAnchorElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAnchorElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLAnchorElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLAnchorElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLAnchorElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAnchorElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLAnchorElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExecutableElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLExecutableElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExecutableElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLExecutableElt_getTypeId" "', argument " "1"" of type '" "ScXMLExecutableElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExecutableElt * >(argp1);
  result = ((ScXMLExecutableElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExecutableElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLExecutableElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExecutableElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLExecutableElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLExecutableElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExecutableElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExecutableElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLExecutableElt" "', argument " "1"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExecutableElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExecutableElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExecutableElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLExecutableElt_copyContents" "', argument " "1"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExecutableElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLExecutableElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExecutableElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExecutableElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExecutableElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLExecutableElt_execute" "', argument " "1"" of type '" "ScXMLExecutableElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExecutableElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLExecutableElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLExecutableElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLExecutableElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLExecutableElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLAssignElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAssignElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_getTypeId" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  result = ((ScXMLAssignElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLAssignElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAssignElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAssignElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAssignElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLAssignElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLAssignElt *)new ScXMLAssignElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAssignElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAssignElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAssignElt" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_setLocationAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_setLocationAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_setLocationAttribute" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_setLocationAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setLocationAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getLocationAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_getLocationAttribute" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  result = (char *)((ScXMLAssignElt const *)arg1)->getLocationAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_setDataIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_setDataIDAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_setDataIDAttribute" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_setDataIDAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setDataIDAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getDataIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_getDataIDAttribute" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  result = (char *)((ScXMLAssignElt const *)arg1)->getDataIDAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_setExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_setExprAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_setExprAttribute" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_setExprAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setExprAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_getExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_getExprAttribute" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  result = (char *)((ScXMLAssignElt const *)arg1)->getExprAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_copyContents" "', argument " "1"" of type '" "ScXMLAssignElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_search" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLAssignElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLAssignElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAssignElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAssignElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAssignElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAssignElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAssignElt_execute" "', argument " "1"" of type '" "ScXMLAssignElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAssignElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAssignElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLAssignElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLAssignElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAssignElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLAssignElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLEvaluator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLEvaluator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_getTypeId" "', argument " "1"" of type '" "ScXMLEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  result = ((ScXMLEvaluator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLEvaluator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLEvaluator::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEvaluator" "', argument " "1"" of type '" "ScXMLEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_setStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_setStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_setStateMachine" "', argument " "1"" of type '" "ScXMLEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvaluator_setStateMachine" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  (arg1)->setStateMachine(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_getStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_getStateMachine" "', argument " "1"" of type '" "ScXMLEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  result = (ScXMLStateMachine *)((ScXMLEvaluator const *)arg1)->getStateMachine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_evaluate" "', argument " "1"" of type '" "ScXMLEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvaluator_evaluate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLEvaluator const *)arg1)->evaluate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_setAtLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  ScXMLDataObj *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_setAtLocation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_setAtLocation" "', argument " "1"" of type '" "ScXMLEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvaluator_setAtLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLEvaluator_setAtLocation" "', argument " "3"" of type '" "ScXMLDataObj *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj * >(argp3);
  result = (SbBool)(arg1)->setAtLocation((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_locate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvaluator_locate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_locate" "', argument " "1"" of type '" "ScXMLEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvaluator_locate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLEvaluator const *)arg1)->locate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvaluator_clearTemporaryVariables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvaluator_clearTemporaryVariables" "', argument " "1"" of type '" "ScXMLEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvaluator * >(argp1);
  (arg1)->clearTemporaryVariables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLEvaluator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEvaluator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = ((ScXMLDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataObj_setContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataObj_setContainer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataObj_setContainer" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataObj_setContainer" "', argument " "2"" of type '" "ScXMLObject *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLObject * >(argp2);
  (arg1)->setContainer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataObj_getContainer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataObj_getContainer" "', argument " "1"" of type '" "ScXMLDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLObject *)((ScXMLDataObj const *)arg1)->getContainer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLObject, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLConstantDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLConstantDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLConstantDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLConstantDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLConstantDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLConstantDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLConstantDataObj * >(argp1);
  result = ((ScXMLConstantDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLConstantDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLConstantDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLConstantDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLConstantDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLConstantDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLConstantDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLConstantDataObj_clone" "', argument " "1"" of type '" "ScXMLConstantDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLConstantDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLConstantDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLConstantDataObj_convertToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLConstantDataObj *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLConstantDataObj_convertToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLConstantDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLConstantDataObj_convertToString" "', argument " "1"" of type '" "ScXMLConstantDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLConstantDataObj * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((ScXMLConstantDataObj const *)arg1)->convertToString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLConstantDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLConstantDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLConstantDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLConstantDataObj" "', argument " "1"" of type '" "ScXMLConstantDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLConstantDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLConstantDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLConstantDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLStringDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLStringDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  result = ((ScXMLStringDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLStringDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLStringDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLStringDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_createFor" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLDataObj *)ScXMLStringDataObj::createFor((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLStringDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLStringDataObj *)new ScXMLStringDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStringDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLStringDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  ScXMLStringDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLStringDataObj" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLStringDataObj *)new ScXMLStringDataObj((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStringDataObj, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLStringDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLStringDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLStringDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLStringDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLStringDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLStringDataObj::ScXMLStringDataObj()\n"
    "    ScXMLStringDataObj::ScXMLStringDataObj(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLStringDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLStringDataObj" "', argument " "1"" of type '" "ScXMLStringDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_setString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_setString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_setString" "', argument " "1"" of type '" "ScXMLStringDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStringDataObj_setString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setString((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_getString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_getString" "', argument " "1"" of type '" "ScXMLStringDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  result = (char *)((ScXMLStringDataObj const *)arg1)->getString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_clone" "', argument " "1"" of type '" "ScXMLStringDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLStringDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStringDataObj_convertToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStringDataObj *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStringDataObj_convertToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStringDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStringDataObj_convertToString" "', argument " "1"" of type '" "ScXMLStringDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStringDataObj * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((ScXMLStringDataObj const *)arg1)->convertToString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *ScXMLStringDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLStringDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLStringDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLRealDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLRealDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLRealDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  result = ((ScXMLRealDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLRealDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLRealDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLRealDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ScXMLRealDataObj_createFor" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (ScXMLDataObj *)ScXMLRealDataObj::createFor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLRealDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLRealDataObj *)new ScXMLRealDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLRealDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLRealDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  ScXMLRealDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScXMLRealDataObj" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (ScXMLRealDataObj *)new ScXMLRealDataObj(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLRealDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLRealDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLRealDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLRealDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ScXMLRealDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLRealDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLRealDataObj::ScXMLRealDataObj()\n"
    "    ScXMLRealDataObj::ScXMLRealDataObj(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLRealDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLRealDataObj" "', argument " "1"" of type '" "ScXMLRealDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_setReal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_setReal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLRealDataObj_setReal" "', argument " "1"" of type '" "ScXMLRealDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLRealDataObj_setReal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setReal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_getReal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLRealDataObj_getReal" "', argument " "1"" of type '" "ScXMLRealDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  result = (double)((ScXMLRealDataObj const *)arg1)->getReal();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLRealDataObj_clone" "', argument " "1"" of type '" "ScXMLRealDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLRealDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLRealDataObj_convertToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLRealDataObj *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLRealDataObj_convertToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLRealDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLRealDataObj_convertToString" "', argument " "1"" of type '" "ScXMLRealDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLRealDataObj * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((ScXMLRealDataObj const *)arg1)->convertToString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *ScXMLRealDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLRealDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLRealDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLBoolDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLBoolDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLBoolDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  result = ((ScXMLBoolDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLBoolDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLBoolDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLBoolDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ScXMLBoolDataObj_createFor" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (ScXMLDataObj *)ScXMLBoolDataObj::createFor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLBoolDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLBoolDataObj *)new ScXMLBoolDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLBoolDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLBoolDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SbBool arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  ScXMLBoolDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScXMLBoolDataObj" "', argument " "1"" of type '" "SbBool""'");
  } 
  arg1 = static_cast< SbBool >(val1);
  result = (ScXMLBoolDataObj *)new ScXMLBoolDataObj(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLBoolDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLBoolDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLBoolDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLBoolDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ScXMLBoolDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLBoolDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLBoolDataObj::ScXMLBoolDataObj()\n"
    "    ScXMLBoolDataObj::ScXMLBoolDataObj(SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLBoolDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLBoolDataObj" "', argument " "1"" of type '" "ScXMLBoolDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_setBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_setBool", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLBoolDataObj_setBool" "', argument " "1"" of type '" "ScXMLBoolDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLBoolDataObj_setBool" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setBool(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_getBool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLBoolDataObj_getBool" "', argument " "1"" of type '" "ScXMLBoolDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  result = (SbBool)((ScXMLBoolDataObj const *)arg1)->getBool();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLBoolDataObj_clone" "', argument " "1"" of type '" "ScXMLBoolDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLBoolDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLBoolDataObj_convertToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLBoolDataObj *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLBoolDataObj_convertToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLBoolDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLBoolDataObj_convertToString" "', argument " "1"" of type '" "ScXMLBoolDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLBoolDataObj * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((ScXMLBoolDataObj const *)arg1)->convertToString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *ScXMLBoolDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLBoolDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLBoolDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLSbDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLSbDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  result = ((ScXMLSbDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLSbDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLSbDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLSbDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_createFor" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLDataObj *)ScXMLSbDataObj::createFor((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSbDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLSbDataObj *)new ScXMLSbDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLSbDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSbDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  ScXMLSbDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLSbDataObj" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLSbDataObj *)new ScXMLSbDataObj((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLSbDataObj, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSbDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLSbDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLSbDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLSbDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLSbDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLSbDataObj::ScXMLSbDataObj()\n"
    "    ScXMLSbDataObj::ScXMLSbDataObj(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLSbDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLSbDataObj" "', argument " "1"" of type '" "ScXMLSbDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_setSbValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_setSbValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_setSbValue" "', argument " "1"" of type '" "ScXMLSbDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSbDataObj_setSbValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSbValue((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_getSbValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_getSbValue" "', argument " "1"" of type '" "ScXMLSbDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  result = (char *)((ScXMLSbDataObj const *)arg1)->getSbValue();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_clone" "', argument " "1"" of type '" "ScXMLSbDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLSbDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSbDataObj_convertToString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSbDataObj *arg1 = 0 ;
  SbString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSbDataObj_convertToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSbDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSbDataObj_convertToString" "', argument " "1"" of type '" "ScXMLSbDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSbDataObj * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))  
    {
      arg2 = new SbString(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbString(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbString * tmp = NULL;
      arg2 = new SbString;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp, SWIGTYPE_p_SbString, 1);
      
      *arg2 = *tmp;
    }
  }
  ((ScXMLSbDataObj const *)arg1)->convertToString(*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *ScXMLSbDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLSbDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLSbDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXMLDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLXMLDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXMLDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLXMLDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXMLDataObj * >(argp1);
  result = ((ScXMLXMLDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXMLDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLXMLDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXMLDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLXMLDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXMLDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLXMLDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLXMLDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLXMLDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLXMLDataObj *)new ScXMLXMLDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLXMLDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLXMLDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXMLDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLXMLDataObj" "', argument " "1"" of type '" "ScXMLXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXMLDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXMLDataObj_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXMLDataObj_clone" "', argument " "1"" of type '" "ScXMLXMLDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXMLDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLXMLDataObj const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLXMLDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLXMLDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLXMLDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExprDataObj * >(argp1);
  result = ((ScXMLExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLExprDataObj" "', argument " "1"" of type '" "ScXMLExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLExprDataObj_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLExprDataObj *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLExprDataObj_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLExprDataObj_evaluate" "', argument " "1"" of type '" "ScXMLExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLExprDataObj_evaluate" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  result = (ScXMLDataObj *)(arg1)->evaluate(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLReferenceDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLReferenceDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLReferenceDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLReferenceDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLReferenceDataObj * >(argp1);
  result = ((ScXMLReferenceDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLReferenceDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLReferenceDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLReferenceDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLReferenceDataObj_createFor" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLDataObj *)ScXMLReferenceDataObj::createFor((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLReferenceDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLReferenceDataObj *)new ScXMLReferenceDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLReferenceDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLReferenceDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  ScXMLReferenceDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLReferenceDataObj" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLReferenceDataObj *)new ScXMLReferenceDataObj((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLReferenceDataObj, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLReferenceDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLReferenceDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLReferenceDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLReferenceDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLReferenceDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLReferenceDataObj::ScXMLReferenceDataObj()\n"
    "    ScXMLReferenceDataObj::ScXMLReferenceDataObj(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLReferenceDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLReferenceDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLReferenceDataObj" "', argument " "1"" of type '" "ScXMLReferenceDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLReferenceDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_setReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_setReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLReferenceDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLReferenceDataObj_setReference" "', argument " "1"" of type '" "ScXMLReferenceDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLReferenceDataObj * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLReferenceDataObj_setReference" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setReference((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_getReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLReferenceDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLReferenceDataObj_getReference" "', argument " "1"" of type '" "ScXMLReferenceDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLReferenceDataObj * >(argp1);
  result = (char *)((ScXMLReferenceDataObj const *)arg1)->getReference();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLReferenceDataObj_evaluateNow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLReferenceDataObj *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  ScXMLDataObj **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLReferenceDataObj_evaluateNow", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLReferenceDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLReferenceDataObj_evaluateNow" "', argument " "1"" of type '" "ScXMLReferenceDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLReferenceDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLReferenceDataObj_evaluateNow" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_ScXMLDataObj,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLReferenceDataObj_evaluateNow" "', argument " "3"" of type '" "ScXMLDataObj *&""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXMLReferenceDataObj_evaluateNow" "', argument " "3"" of type '" "ScXMLDataObj *&""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj ** >(argp3);
  result = (SbBool)((ScXMLReferenceDataObj const *)arg1)->evaluateNow(arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLReferenceDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLReferenceDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLReferenceDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAndOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  result = ((ScXMLAndOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLAndOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAndOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAndOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAndOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLAndOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAndOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLAndOpExprDataObj *)new ScXMLAndOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAndOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAndOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLAndOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLAndOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLAndOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLAndOpExprDataObj *)new ScXMLAndOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAndOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAndOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLAndOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLAndOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLAndOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLAndOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLAndOpExprDataObj::ScXMLAndOpExprDataObj()\n"
    "    ScXMLAndOpExprDataObj::ScXMLAndOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAndOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAndOpExprDataObj" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAndOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAndOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAndOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAndOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAndOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAndOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAndOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAndOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLAndOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAndOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAndOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLAndOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAndOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLAndOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLOrOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  result = ((ScXMLOrOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLOrOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLOrOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLOrOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOrOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLOrOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLOrOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLOrOpExprDataObj *)new ScXMLOrOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOrOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLOrOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLOrOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLOrOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLOrOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLOrOpExprDataObj *)new ScXMLOrOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOrOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLOrOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLOrOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLOrOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLOrOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLOrOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLOrOpExprDataObj::ScXMLOrOpExprDataObj()\n"
    "    ScXMLOrOpExprDataObj::ScXMLOrOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLOrOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLOrOpExprDataObj" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOrOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLOrOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOrOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOrOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOrOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOrOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOrOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOrOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLOrOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOrOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLOrOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLOrOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLOrOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLOrOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNotOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLNotOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNotOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNotOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNotOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLNotOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNotOpExprDataObj * >(argp1);
  result = ((ScXMLNotOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNotOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLNotOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNotOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLNotOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNotOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLNotOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNotOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLDataObj *)ScXMLNotOpExprDataObj::createFor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNotOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLNotOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLNotOpExprDataObj *)new ScXMLNotOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLNotOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNotOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ScXMLNotOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLNotOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLNotOpExprDataObj *)new ScXMLNotOpExprDataObj(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLNotOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNotOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLNotOpExprDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLNotOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLNotOpExprDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLNotOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLNotOpExprDataObj::ScXMLNotOpExprDataObj()\n"
    "    ScXMLNotOpExprDataObj::ScXMLNotOpExprDataObj(ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLNotOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNotOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNotOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLNotOpExprDataObj" "', argument " "1"" of type '" "ScXMLNotOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNotOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNotOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNotOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNotOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNotOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLNotOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNotOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLNotOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNotOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNotOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNotOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNotOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLNotOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNotOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLNotOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLNotOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLNotOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLNotOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLEqualsOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  result = ((ScXMLEqualsOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLEqualsOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLEqualsOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLEqualsOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEqualsOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLEqualsOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLEqualsOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLEqualsOpExprDataObj *)new ScXMLEqualsOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEqualsOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLEqualsOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLEqualsOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLEqualsOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLEqualsOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLEqualsOpExprDataObj *)new ScXMLEqualsOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEqualsOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLEqualsOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLEqualsOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLEqualsOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLEqualsOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLEqualsOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLEqualsOpExprDataObj::ScXMLEqualsOpExprDataObj()\n"
    "    ScXMLEqualsOpExprDataObj::ScXMLEqualsOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLEqualsOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEqualsOpExprDataObj" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEqualsOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLEqualsOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEqualsOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEqualsOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEqualsOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEqualsOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLEqualsOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEqualsOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLEqualsOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLEqualsOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEqualsOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLEqualsOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAddOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  result = ((ScXMLAddOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLAddOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAddOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAddOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAddOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLAddOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAddOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLAddOpExprDataObj *)new ScXMLAddOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAddOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAddOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLAddOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLAddOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLAddOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLAddOpExprDataObj *)new ScXMLAddOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAddOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAddOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLAddOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLAddOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLAddOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLAddOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLAddOpExprDataObj::ScXMLAddOpExprDataObj()\n"
    "    ScXMLAddOpExprDataObj::ScXMLAddOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAddOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAddOpExprDataObj" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAddOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAddOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAddOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAddOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAddOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAddOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLAddOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAddOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAddOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLAddOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAddOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLAddOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLSubtractOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  result = ((ScXMLSubtractOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLSubtractOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLSubtractOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLSubtractOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSubtractOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLSubtractOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSubtractOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLSubtractOpExprDataObj *)new ScXMLSubtractOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLSubtractOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSubtractOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLSubtractOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLSubtractOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLSubtractOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLSubtractOpExprDataObj *)new ScXMLSubtractOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLSubtractOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSubtractOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLSubtractOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLSubtractOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLSubtractOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLSubtractOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLSubtractOpExprDataObj::ScXMLSubtractOpExprDataObj()\n"
    "    ScXMLSubtractOpExprDataObj::ScXMLSubtractOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLSubtractOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLSubtractOpExprDataObj" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSubtractOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLSubtractOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSubtractOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSubtractOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSubtractOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSubtractOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLSubtractOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSubtractOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLSubtractOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLSubtractOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLSubtractOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLSubtractOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLMultiplyOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  result = ((ScXMLMultiplyOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLMultiplyOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLMultiplyOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLMultiplyOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMultiplyOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLMultiplyOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLMultiplyOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLMultiplyOpExprDataObj *)new ScXMLMultiplyOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLMultiplyOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLMultiplyOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLMultiplyOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLMultiplyOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLMultiplyOpExprDataObj *)new ScXMLMultiplyOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLMultiplyOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLMultiplyOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLMultiplyOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLMultiplyOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLMultiplyOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLMultiplyOpExprDataObj::ScXMLMultiplyOpExprDataObj()\n"
    "    ScXMLMultiplyOpExprDataObj::ScXMLMultiplyOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLMultiplyOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLMultiplyOpExprDataObj" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMultiplyOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLMultiplyOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMultiplyOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMultiplyOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMultiplyOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMultiplyOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLMultiplyOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMultiplyOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLMultiplyOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLMultiplyOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLMultiplyOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLMultiplyOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLDivideOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  result = ((ScXMLDivideOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLDivideOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLDivideOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLDivideOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDivideOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLDivideOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDivideOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLDivideOpExprDataObj *)new ScXMLDivideOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDivideOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDivideOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLDivideOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLDivideOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLDivideOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDivideOpExprDataObj *)new ScXMLDivideOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDivideOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDivideOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLDivideOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLDivideOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLDivideOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLDivideOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLDivideOpExprDataObj::ScXMLDivideOpExprDataObj()\n"
    "    ScXMLDivideOpExprDataObj::ScXMLDivideOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLDivideOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLDivideOpExprDataObj" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDivideOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLDivideOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDivideOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDivideOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDivideOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDivideOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLDivideOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDivideOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLDivideOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLDivideOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLDivideOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLDivideOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNegateOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLNegateOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNegateOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNegateOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNegateOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLNegateOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNegateOpExprDataObj * >(argp1);
  result = ((ScXMLNegateOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNegateOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLNegateOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNegateOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLNegateOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNegateOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLNegateOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNegateOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLDataObj *)ScXMLNegateOpExprDataObj::createFor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNegateOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLNegateOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLNegateOpExprDataObj *)new ScXMLNegateOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLNegateOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNegateOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ScXMLNegateOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLNegateOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLNegateOpExprDataObj *)new ScXMLNegateOpExprDataObj(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLNegateOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLNegateOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLNegateOpExprDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLNegateOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLNegateOpExprDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLNegateOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLNegateOpExprDataObj::ScXMLNegateOpExprDataObj()\n"
    "    ScXMLNegateOpExprDataObj::ScXMLNegateOpExprDataObj(ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLNegateOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNegateOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNegateOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLNegateOpExprDataObj" "', argument " "1"" of type '" "ScXMLNegateOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNegateOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNegateOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLNegateOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNegateOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNegateOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLNegateOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNegateOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLNegateOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLNegateOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLNegateOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLNegateOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLNegateOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLNegateOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLNegateOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLNegateOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLNegateOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLNegateOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLNegateOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinEvaluator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_getTypeId" "', argument " "1"" of type '" "ScXMLCoinEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  result = ((ScXMLCoinEvaluator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinEvaluator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinEvaluator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinEvaluator::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinEvaluator", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinEvaluator *)new ScXMLCoinEvaluator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinEvaluator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinEvaluator" "', argument " "1"" of type '" "ScXMLCoinEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_setStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_setStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_setStateMachine" "', argument " "1"" of type '" "ScXMLCoinEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinEvaluator_setStateMachine" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  (arg1)->setStateMachine(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_evaluate" "', argument " "1"" of type '" "ScXMLCoinEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinEvaluator_evaluate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLCoinEvaluator const *)arg1)->evaluate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_setAtLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  ScXMLDataObj *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_setAtLocation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_setAtLocation" "', argument " "1"" of type '" "ScXMLCoinEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinEvaluator_setAtLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLCoinEvaluator_setAtLocation" "', argument " "3"" of type '" "ScXMLDataObj *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj * >(argp3);
  result = (SbBool)(arg1)->setAtLocation((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_locate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEvaluator_locate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_locate" "', argument " "1"" of type '" "ScXMLCoinEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinEvaluator_locate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLCoinEvaluator const *)arg1)->locate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_clearTemporaryVariables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_clearTemporaryVariables" "', argument " "1"" of type '" "ScXMLCoinEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  (arg1)->clearTemporaryVariables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEvaluator_dumpTemporaries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEvaluator_dumpTemporaries" "', argument " "1"" of type '" "ScXMLCoinEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEvaluator * >(argp1);
  (arg1)->dumpTemporaries();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinEvaluator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinEvaluator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinEvaluator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinEqualsOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEqualsOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinEqualsOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEqualsOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEqualsOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinEqualsOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinEqualsOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEqualsOpExprDataObj * >(argp1);
  result = ((ScXMLCoinEqualsOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEqualsOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEqualsOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinEqualsOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEqualsOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEqualsOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinEqualsOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinEqualsOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinEqualsOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinEqualsOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinEqualsOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEqualsOpExprDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinEqualsOpExprDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinEqualsOpExprDataObj *)new ScXMLCoinEqualsOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinEqualsOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinEqualsOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinEqualsOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinEqualsOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinEqualsOpExprDataObj" "', argument " "1"" of type '" "ScXMLCoinEqualsOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinEqualsOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinEqualsOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinEqualsOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinEqualsOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinAddOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinAddOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinAddOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinAddOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinAddOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinAddOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinAddOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinAddOpExprDataObj * >(argp1);
  result = ((ScXMLCoinAddOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinAddOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinAddOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinAddOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinAddOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinAddOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinAddOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinAddOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinAddOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinAddOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinAddOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinAddOpExprDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinAddOpExprDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinAddOpExprDataObj *)new ScXMLCoinAddOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinAddOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinAddOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinAddOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinAddOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinAddOpExprDataObj" "', argument " "1"" of type '" "ScXMLCoinAddOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinAddOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinAddOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinAddOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinAddOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinSubtractOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinSubtractOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinSubtractOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinSubtractOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinSubtractOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinSubtractOpExprDataObj * >(argp1);
  result = ((ScXMLCoinSubtractOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinSubtractOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinSubtractOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinSubtractOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinSubtractOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinSubtractOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinSubtractOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinSubtractOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinSubtractOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinSubtractOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinSubtractOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLCoinSubtractOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinSubtractOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinSubtractOpExprDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinSubtractOpExprDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinSubtractOpExprDataObj *)new ScXMLCoinSubtractOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinSubtractOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinSubtractOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinSubtractOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinSubtractOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinSubtractOpExprDataObj" "', argument " "1"" of type '" "ScXMLCoinSubtractOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinSubtractOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinSubtractOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinSubtractOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinSubtractOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinMultiplyOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinMultiplyOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinMultiplyOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinMultiplyOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinMultiplyOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinMultiplyOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinMultiplyOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinMultiplyOpExprDataObj * >(argp1);
  result = ((ScXMLCoinMultiplyOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinMultiplyOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinMultiplyOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinMultiplyOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinMultiplyOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinMultiplyOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinMultiplyOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinMultiplyOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinMultiplyOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinMultiplyOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinMultiplyOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinMultiplyOpExprDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinMultiplyOpExprDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinMultiplyOpExprDataObj *)new ScXMLCoinMultiplyOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinMultiplyOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinMultiplyOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinMultiplyOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinMultiplyOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinMultiplyOpExprDataObj" "', argument " "1"" of type '" "ScXMLCoinMultiplyOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinMultiplyOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinMultiplyOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinMultiplyOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinMultiplyOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinDivideOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinDivideOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinDivideOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinDivideOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinDivideOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinDivideOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinDivideOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinDivideOpExprDataObj * >(argp1);
  result = ((ScXMLCoinDivideOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinDivideOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinDivideOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinDivideOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinDivideOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinDivideOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinDivideOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinDivideOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinDivideOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinDivideOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinDivideOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinDivideOpExprDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLCoinDivideOpExprDataObj", 0, 0, 0)) SWIG_fail;
  result = (ScXMLCoinDivideOpExprDataObj *)new ScXMLCoinDivideOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinDivideOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinDivideOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinDivideOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinDivideOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinDivideOpExprDataObj" "', argument " "1"" of type '" "ScXMLCoinDivideOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinDivideOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinDivideOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinDivideOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinDivideOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinLengthFuncExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLCoinLengthFuncExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinLengthFuncExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinLengthFuncExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLCoinLengthFuncExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinLengthFuncExprDataObj * >(argp1);
  result = ((ScXMLCoinLengthFuncExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinLengthFuncExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLCoinLengthFuncExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinLengthFuncExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinLengthFuncExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinLengthFuncExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLCoinLengthFuncExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinLengthFuncExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLDataObj *)ScXMLCoinLengthFuncExprDataObj::createFor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinLengthFuncExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLCoinLengthFuncExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLCoinLengthFuncExprDataObj *)new ScXMLCoinLengthFuncExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinLengthFuncExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ScXMLCoinLengthFuncExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLCoinLengthFuncExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  result = (ScXMLCoinLengthFuncExprDataObj *)new ScXMLCoinLengthFuncExprDataObj(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLCoinLengthFuncExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLCoinLengthFuncExprDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLCoinLengthFuncExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLCoinLengthFuncExprDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLCoinLengthFuncExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLCoinLengthFuncExprDataObj::ScXMLCoinLengthFuncExprDataObj()\n"
    "    ScXMLCoinLengthFuncExprDataObj::ScXMLCoinLengthFuncExprDataObj(ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLCoinLengthFuncExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinLengthFuncExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLCoinLengthFuncExprDataObj" "', argument " "1"" of type '" "ScXMLCoinLengthFuncExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinLengthFuncExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_setExpr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinLengthFuncExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLCoinLengthFuncExprDataObj_setExpr", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinLengthFuncExprDataObj_setExpr" "', argument " "1"" of type '" "ScXMLCoinLengthFuncExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinLengthFuncExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLCoinLengthFuncExprDataObj_setExpr" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setExpr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLCoinLengthFuncExprDataObj_getExpr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLCoinLengthFuncExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLCoinLengthFuncExprDataObj_getExpr" "', argument " "1"" of type '" "ScXMLCoinLengthFuncExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLCoinLengthFuncExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLCoinLengthFuncExprDataObj const *)arg1)->getExpr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLCoinLengthFuncExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLCoinLengthFuncExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLCoinLengthFuncExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLContentElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLContentElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLContentElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLContentElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLContentElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLContentElt_getTypeId" "', argument " "1"" of type '" "ScXMLContentElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLContentElt * >(argp1);
  result = ((ScXMLContentElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLContentElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLContentElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLContentElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLContentElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLContentElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLContentElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLContentElt *)new ScXMLContentElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLContentElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLContentElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLContentElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLContentElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLContentElt" "', argument " "1"" of type '" "ScXMLContentElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLContentElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLContentElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLContentElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLContentElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLContentElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLContentElt_copyContents" "', argument " "1"" of type '" "ScXMLContentElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLContentElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLContentElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLContentElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLContentElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLContentElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLDataElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLDataElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLDataElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_getTypeId" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = ((ScXMLDataElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLDataElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDataElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLDataElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLDataElt *)new ScXMLDataElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLDataElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLDataElt" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_setIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_setIDAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_setIDAttribute" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_setIDAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setIDAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_getIDAttribute" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = (char *)((ScXMLDataElt const *)arg1)->getIDAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_setSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_setSrcAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_setSrcAttribute" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_setSrcAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSrcAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_getSrcAttribute" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = (char *)((ScXMLDataElt const *)arg1)->getSrcAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_setExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_setExprAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_setExprAttribute" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_setExprAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setExprAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_getExprAttribute" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = (char *)((ScXMLDataElt const *)arg1)->getExprAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_copyContents" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_search" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLDataElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLDataElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_setValueObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataElt_setValueObj", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_setValueObj" "', argument " "1"" of type '" "ScXMLDataElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataElt_setValueObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setValueObj(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataElt_getValueObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataElt_getValueObj" "', argument " "1"" of type '" "ScXMLDataElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataElt * >(argp1);
  result = (ScXMLDataObj *)((ScXMLDataElt const *)arg1)->getValueObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLDataElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLDataElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLDataElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLDataModelElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLDataModelElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_getTypeId" "', argument " "1"" of type '" "ScXMLDataModelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  result = ((ScXMLDataModelElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLDataModelElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataModelElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLDataModelElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDataModelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLDataModelElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLDataModelElt *)new ScXMLDataModelElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataModelElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLDataModelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLDataModelElt" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_setSchemaAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_setSchemaAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_setSchemaAttribute" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataModelElt_setSchemaAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSchemaAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getSchemaAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_getSchemaAttribute" "', argument " "1"" of type '" "ScXMLDataModelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  result = (char *)((ScXMLDataModelElt const *)arg1)->getSchemaAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_copyContents" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataModelElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getNumData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_getNumData" "', argument " "1"" of type '" "ScXMLDataModelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  result = (int)((ScXMLDataModelElt const *)arg1)->getNumData();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_getData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_getData" "', argument " "1"" of type '" "ScXMLDataModelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLDataModelElt_getData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLDataElt *)((ScXMLDataModelElt const *)arg1)->getData(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_addData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  ScXMLDataElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_addData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_addData" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataModelElt_addData" "', argument " "2"" of type '" "ScXMLDataElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataElt * >(argp2);
  (arg1)->addData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_removeData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  ScXMLDataElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_removeData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_removeData" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataModelElt_removeData" "', argument " "2"" of type '" "ScXMLDataElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataElt * >(argp2);
  (arg1)->removeData(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_clearAllData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_clearAllData" "', argument " "1"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  (arg1)->clearAllData();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDataModelElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataModelElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDataModelElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDataModelElt_search" "', argument " "1"" of type '" "ScXMLDataModelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataModelElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDataModelElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLDataModelElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLDataModelElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLDataModelElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLDataModelElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLDataModelElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLDocument_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLDocument::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_getTypeId" "', argument " "1"" of type '" "ScXMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  result = ((ScXMLDocument const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLDocument::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLDocument::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLDocument::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_readFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDocument *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_readFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLDocument *)ScXMLDocument::readFile((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_readBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbByteBuffer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDocument *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SbByteBuffer,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_readBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXMLDocument_readBuffer" "', argument " "1"" of type '" "SbByteBuffer const &""'"); 
  }
  arg1 = reinterpret_cast< SbByteBuffer * >(argp1);
  result = (ScXMLDocument *)ScXMLDocument::readBuffer((SbByteBuffer const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_readXMLData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  cc_xml_doc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDocument *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_cc_xml_doc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_readXMLData" "', argument " "1"" of type '" "cc_xml_doc *""'"); 
  }
  arg1 = reinterpret_cast< cc_xml_doc * >(argp1);
  result = (ScXMLDocument *)ScXMLDocument::readXMLData(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLDocument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLDocument", 0, 0, 0)) SWIG_fail;
  result = (ScXMLDocument *)new ScXMLDocument();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLDocument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLDocument" "', argument " "1"" of type '" "ScXMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_setFilename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_setFilename", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_setFilename" "', argument " "1"" of type '" "ScXMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDocument_setFilename" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setFilename((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_getFilename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_getFilename" "', argument " "1"" of type '" "ScXMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  result = (char *)((ScXMLDocument const *)arg1)->getFilename();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_setRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  ScXMLScxmlElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_setRoot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_setRoot" "', argument " "1"" of type '" "ScXMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLDocument_setRoot" "', argument " "2"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLScxmlElt * >(argp2);
  (arg1)->setRoot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_getRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLScxmlElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_getRoot" "', argument " "1"" of type '" "ScXMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  result = (ScXMLScxmlElt *)((ScXMLDocument const *)arg1)->getRoot();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_getStateById(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLAbstractStateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_getStateById", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_getStateById" "', argument " "1"" of type '" "ScXMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  result = (ScXMLAbstractStateElt *)((ScXMLDocument const *)arg1)->getStateById(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAbstractStateElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLDocument_getDataById(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDocument *arg1 = 0 ;
  SbName arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLDocument_getDataById", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLDocument_getDataById" "', argument " "1"" of type '" "ScXMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDocument * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * namePtr;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&namePtr, SWIGTYPE_p_SbName, 1);
      
      arg2 = *namePtr;
    }
  }
  result = (ScXMLDataElt *)((ScXMLDocument const *)arg1)->getDataById(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLDocument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLDocument, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLDocument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLECMAScriptEvaluator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLECMAScriptEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLECMAScriptEvaluator_getTypeId" "', argument " "1"" of type '" "ScXMLECMAScriptEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLECMAScriptEvaluator * >(argp1);
  result = ((ScXMLECMAScriptEvaluator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLECMAScriptEvaluator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLECMAScriptEvaluator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLECMAScriptEvaluator::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLECMAScriptEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLECMAScriptEvaluator", 0, 0, 0)) SWIG_fail;
  result = (ScXMLECMAScriptEvaluator *)new ScXMLECMAScriptEvaluator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLECMAScriptEvaluator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLECMAScriptEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLECMAScriptEvaluator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLECMAScriptEvaluator" "', argument " "1"" of type '" "ScXMLECMAScriptEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLECMAScriptEvaluator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLECMAScriptEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLECMAScriptEvaluator_evaluate" "', argument " "1"" of type '" "ScXMLECMAScriptEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLECMAScriptEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLECMAScriptEvaluator_evaluate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLECMAScriptEvaluator const *)arg1)->evaluate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_setAtLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  ScXMLDataObj *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_setAtLocation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLECMAScriptEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLECMAScriptEvaluator_setAtLocation" "', argument " "1"" of type '" "ScXMLECMAScriptEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLECMAScriptEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLECMAScriptEvaluator_setAtLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLECMAScriptEvaluator_setAtLocation" "', argument " "3"" of type '" "ScXMLDataObj *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj * >(argp3);
  result = (SbBool)(arg1)->setAtLocation((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLECMAScriptEvaluator_locate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLECMAScriptEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLECMAScriptEvaluator_locate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLECMAScriptEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLECMAScriptEvaluator_locate" "', argument " "1"" of type '" "ScXMLECMAScriptEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLECMAScriptEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLECMAScriptEvaluator_locate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLECMAScriptEvaluator const *)arg1)->locate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *ScXMLECMAScriptEvaluator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLECMAScriptEvaluator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLECMAScriptEvaluator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLElseElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLElseElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLElseElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseElt_getTypeId" "', argument " "1"" of type '" "ScXMLElseElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseElt * >(argp1);
  result = ((ScXMLElseElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLElseElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLElseElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLElseElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLElseElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLElseElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLElseElt *)new ScXMLElseElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElseElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLElseElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLElseElt" "', argument " "1"" of type '" "ScXMLElseElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseElt_copyContents" "', argument " "1"" of type '" "ScXMLElseElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElseElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLElseElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLElseElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLElseElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLElseIfElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLElseIfElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_getTypeId" "', argument " "1"" of type '" "ScXMLElseIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  result = ((ScXMLElseIfElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLElseIfElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLElseIfElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLElseIfElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLElseIfElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLElseIfElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLElseIfElt *)new ScXMLElseIfElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElseIfElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLElseIfElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLElseIfElt" "', argument " "1"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_setCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_setCondAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_setCondAttribute" "', argument " "1"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElseIfElt_setCondAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setCondAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_getCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_getCondAttribute" "', argument " "1"" of type '" "ScXMLElseIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  result = (char *)((ScXMLElseIfElt const *)arg1)->getCondAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_copyContents" "', argument " "1"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElseIfElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLElseIfElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLElseIfElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLElseIfElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLElseIfElt_search" "', argument " "1"" of type '" "ScXMLElseIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLElseIfElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLElseIfElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLElseIfElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLElseIfElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLElseIfElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLElseIfElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLElseIfElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_getTypeId" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  result = ((ScXMLEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLEvent::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLEvent::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLEvent", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEvent *)new ScXMLEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEvent" "', argument " "1"" of type '" "ScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_setEventName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_setEventName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_setEventName" "', argument " "1"" of type '" "ScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setEventName((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_getEventName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_getEventName" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  result = (SbName *) &((ScXMLEvent const *)arg1)->getEventName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_clone" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  result = (ScXMLEvent *)((ScXMLEvent const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_setAssociation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_setAssociation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_setAssociation" "', argument " "1"" of type '" "ScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvent_setAssociation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLEvent_setAssociation" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->setAssociation((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_getAssociation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_getAssociation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_getAssociation" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvent_getAssociation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (char *)((ScXMLEvent const *)arg1)->getAssociation((char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_getNumAssociations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_getNumAssociations" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  result = ((ScXMLEvent const *)arg1)->getNumAssociations();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEvent_getAssociationKeys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEvent *arg1 = 0 ;
  SbList< char const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEvent_getAssociationKeys", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEvent_getAssociationKeys" "', argument " "1"" of type '" "ScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbListT_char_const_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEvent_getAssociationKeys" "', argument " "2"" of type '" "SbList< char const * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXMLEvent_getAssociationKeys" "', argument " "2"" of type '" "SbList< char const * > &""'"); 
  }
  arg2 = reinterpret_cast< SbList< char const * > * >(argp2);
  result = ((ScXMLEvent const *)arg1)->getAssociationKeys(*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLEventElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLEventElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLEventElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_getTypeId" "', argument " "1"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  result = ((ScXMLEventElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLEventElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLEventElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLEventElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLEventElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLEventElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEventElt *)new ScXMLEventElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEventElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLEventElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLEventElt" "', argument " "1"" of type '" "ScXMLEventElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_setNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_setNameAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_setNameAttribute" "', argument " "1"" of type '" "ScXMLEventElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventElt_setNameAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setNameAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_getNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_getNameAttribute" "', argument " "1"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  result = (char *)((ScXMLEventElt const *)arg1)->getNameAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLEventElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_copyContents" "', argument " "1"" of type '" "ScXMLEventElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_search" "', argument " "1"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLEventElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLEventElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_createEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  ScXMLEventTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_createEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_createEvent" "', argument " "1"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventElt_createEvent" "', argument " "2"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEventTarget * >(argp2);
  result = (ScXMLEvent *)((ScXMLEventElt const *)arg1)->createEvent(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLEventElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEventElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLEventElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLEventElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLEventElt_execute" "', argument " "1"" of type '" "ScXMLEventElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLEventElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLEventElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLEventElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLEventElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLEventElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLEventElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLFinalElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLFinalElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLFinalElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_getTypeId" "', argument " "1"" of type '" "ScXMLFinalElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  result = ((ScXMLFinalElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLFinalElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLFinalElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLFinalElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLFinalElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLFinalElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLFinalElt *)new ScXMLFinalElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLFinalElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLFinalElt" "', argument " "1"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_setOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  ScXMLOnEntryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_setOnEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_setOnEntry" "', argument " "1"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLFinalElt_setOnEntry" "', argument " "2"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnEntryElt * >(argp2);
  (arg1)->setOnEntry(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_getOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnEntryElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_getOnEntry" "', argument " "1"" of type '" "ScXMLFinalElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  result = (ScXMLOnEntryElt *)((ScXMLFinalElt const *)arg1)->getOnEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_setOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  ScXMLOnExitElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_setOnExit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_setOnExit" "', argument " "1"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLFinalElt_setOnExit" "', argument " "2"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnExitElt * >(argp2);
  (arg1)->setOnExit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_getOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnExitElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_getOnExit" "', argument " "1"" of type '" "ScXMLFinalElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  result = (ScXMLOnExitElt *)((ScXMLFinalElt const *)arg1)->getOnExit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_copyContents" "', argument " "1"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLFinalElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalElt_search" "', argument " "1"" of type '" "ScXMLFinalElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLFinalElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLFinalElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLFinalElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLFinalElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLFinalElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLFinalElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLFinalizeElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLFinalizeElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalizeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalizeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalizeElt_getTypeId" "', argument " "1"" of type '" "ScXMLFinalizeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalizeElt * >(argp1);
  result = ((ScXMLFinalizeElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLFinalizeElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLFinalizeElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLFinalizeElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLFinalizeElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalizeElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLFinalizeElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLFinalizeElt *)new ScXMLFinalizeElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalizeElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLFinalizeElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalizeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalizeElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLFinalizeElt" "', argument " "1"" of type '" "ScXMLFinalizeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalizeElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLFinalizeElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLFinalizeElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLFinalizeElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLFinalizeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLFinalizeElt_copyContents" "', argument " "1"" of type '" "ScXMLFinalizeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLFinalizeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLFinalizeElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLFinalizeElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLFinalizeElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLFinalizeElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLHistoryElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLHistoryElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_getTypeId" "', argument " "1"" of type '" "ScXMLHistoryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  result = ((ScXMLHistoryElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLHistoryElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLHistoryElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLHistoryElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLHistoryElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLHistoryElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLHistoryElt *)new ScXMLHistoryElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLHistoryElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLHistoryElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLHistoryElt" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_setIdAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_setIdAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_setIdAttribute" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLHistoryElt_setIdAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setIdAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getIdAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_getIdAttribute" "', argument " "1"" of type '" "ScXMLHistoryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  result = (char *)((ScXMLHistoryElt const *)arg1)->getIdAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_setTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_setTypeAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_setTypeAttribute" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLHistoryElt_setTypeAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTypeAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_getTypeAttribute" "', argument " "1"" of type '" "ScXMLHistoryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  result = (char *)((ScXMLHistoryElt const *)arg1)->getTypeAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_copyContents" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLHistoryElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_search" "', argument " "1"" of type '" "ScXMLHistoryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLHistoryElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLHistoryElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLHistoryElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_setTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLHistoryElt_setTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_setTransition" "', argument " "1"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLHistoryElt_setTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->setTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLHistoryElt_getTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLHistoryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLTransitionElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLHistoryElt_getTransition" "', argument " "1"" of type '" "ScXMLHistoryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLHistoryElt * >(argp1);
  result = (ScXMLTransitionElt *)((ScXMLHistoryElt const *)arg1)->getTransition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLHistoryElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLHistoryElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLHistoryElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLIfElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLIfElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLIfElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getTypeId" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  result = ((ScXMLIfElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLIfElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLIfElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLIfElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLIfElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLIfElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLIfElt *)new ScXMLIfElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLIfElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLIfElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLIfElt" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_setCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_setCondAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_setCondAttribute" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_setCondAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setCondAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getCondAttribute" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  result = (char *)((ScXMLIfElt const *)arg1)->getCondAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_copyContents" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_search" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLIfElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLIfElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getNumElseIfs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getNumElseIfs" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  result = (int)((ScXMLIfElt const *)arg1)->getNumElseIfs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getElseIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLElseIfElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_getElseIf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getElseIf" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLIfElt_getElseIf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLElseIfElt *)((ScXMLIfElt const *)arg1)->getElseIf(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_addElseIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLElseIfElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_addElseIf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_addElseIf" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_addElseIf" "', argument " "2"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElseIfElt * >(argp2);
  (arg1)->addElseIf(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_removeElseIf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLElseIfElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_removeElseIf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_removeElseIf" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElseIfElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_removeElseIf" "', argument " "2"" of type '" "ScXMLElseIfElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElseIfElt * >(argp2);
  (arg1)->removeElseIf(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_clearAllElseIfs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_clearAllElseIfs" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  (arg1)->clearAllElseIfs();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_setElse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLElseElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_setElse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_setElse" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElseElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_setElse" "', argument " "2"" of type '" "ScXMLElseElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElseElt * >(argp2);
  (arg1)->setElse(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getElse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLElseElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getElse" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  result = (ScXMLElseElt *)((ScXMLIfElt const *)arg1)->getElse();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElseElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getNumExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_getNumExecutables", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getNumExecutables" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_getNumExecutables" "', argument " "2"" of type '" "ScXMLExecutableElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  result = (int)((ScXMLIfElt const *)arg1)->getNumExecutables((ScXMLExecutableElt const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_getExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLExecutableElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_getExecutable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_getExecutable" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_getExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ScXMLIfElt_getExecutable" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (ScXMLExecutableElt *)((ScXMLIfElt const *)arg1)->getExecutable((ScXMLExecutableElt const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_addExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  ScXMLExecutableElt *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_addExecutable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_addExecutable" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_addExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLIfElt_addExecutable" "', argument " "3"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLExecutableElt * >(argp3);
  (arg1)->addExecutable(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_removeExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  ScXMLExecutableElt *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_removeExecutable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_removeExecutable" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_removeExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLIfElt_removeExecutable" "', argument " "3"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLExecutableElt * >(argp3);
  (arg1)->removeExecutable(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_clearAllExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_clearAllExecutables", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_clearAllExecutables" "', argument " "1"" of type '" "ScXMLIfElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_clearAllExecutables" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->clearAllExecutables(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLIfElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLIfElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLIfElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLIfElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLIfElt_execute" "', argument " "1"" of type '" "ScXMLIfElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLIfElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLIfElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLIfElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLIfElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLIfElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLIfElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLInitialElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLInitialElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLInitialElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInitialElt_getTypeId" "', argument " "1"" of type '" "ScXMLInitialElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  result = ((ScXMLInitialElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLInitialElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLInitialElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLInitialElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLInitialElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLInitialElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLInitialElt *)new ScXMLInitialElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInitialElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLInitialElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLInitialElt" "', argument " "1"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInitialElt_copyContents" "', argument " "1"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInitialElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInitialElt_search" "', argument " "1"" of type '" "ScXMLInitialElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInitialElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLInitialElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLInitialElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_setTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInitialElt_setTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInitialElt_setTransition" "', argument " "1"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInitialElt_setTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->setTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInitialElt_getTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInitialElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLTransitionElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInitialElt_getTransition" "', argument " "1"" of type '" "ScXMLInitialElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInitialElt * >(argp1);
  result = (ScXMLTransitionElt *)((ScXMLInitialElt const *)arg1)->getTransition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLInitialElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLInitialElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLInitialElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLInvokeElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLInvokeElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getTypeId" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = ((ScXMLInvokeElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLInvokeElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLInvokeElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLInvokeElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLInvokeElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLInvokeElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLInvokeElt *)new ScXMLInvokeElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInvokeElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLInvokeElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLInvokeElt" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_setTargetTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_setTargetTypeAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_setTargetTypeAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_setTargetTypeAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTargetTypeAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getTargetTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getTargetTypeAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (char *)((ScXMLInvokeElt const *)arg1)->getTargetTypeAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_setSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_setSrcAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_setSrcAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_setSrcAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSrcAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getSrcAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (char *)((ScXMLInvokeElt const *)arg1)->getSrcAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_setSrcExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_setSrcExprAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_setSrcExprAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_setSrcExprAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSrcExprAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getSrcExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getSrcExprAttribute" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (char *)((ScXMLInvokeElt const *)arg1)->getSrcExprAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_copyContents" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_search" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLInvokeElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLInvokeElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getNumParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getNumParams" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (int)((ScXMLInvokeElt const *)arg1)->getNumParams();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLParamElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_getParam", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getParam" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLInvokeElt_getParam" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLParamElt *)((ScXMLInvokeElt const *)arg1)->getParam(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_addParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  ScXMLParamElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_addParam", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_addParam" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_addParam" "', argument " "2"" of type '" "ScXMLParamElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParamElt * >(argp2);
  (arg1)->addParam(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_removeParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  ScXMLParamElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_removeParam", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_removeParam" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_removeParam" "', argument " "2"" of type '" "ScXMLParamElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParamElt * >(argp2);
  (arg1)->removeParam(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_clearAllParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_clearAllParams" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  (arg1)->clearAllParams();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_setFinalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  ScXMLFinalizeElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_setFinalize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_setFinalize" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalizeElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_setFinalize" "', argument " "2"" of type '" "ScXMLFinalizeElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalizeElt * >(argp2);
  (arg1)->setFinalize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getFinalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLFinalizeElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getFinalize" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (ScXMLFinalizeElt *)((ScXMLInvokeElt const *)arg1)->getFinalize();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalizeElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_setContent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  ScXMLContentElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInvokeElt_setContent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_setContent" "', argument " "1"" of type '" "ScXMLInvokeElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLContentElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInvokeElt_setContent" "', argument " "2"" of type '" "ScXMLContentElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLContentElt * >(argp2);
  (arg1)->setContent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInvokeElt_getContent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInvokeElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLContentElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInvokeElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInvokeElt_getContent" "', argument " "1"" of type '" "ScXMLInvokeElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInvokeElt * >(argp1);
  result = (ScXMLContentElt *)((ScXMLInvokeElt const *)arg1)->getContent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLContentElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLInvokeElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLInvokeElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLInvokeElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLLogElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLLogElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLLogElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_getTypeId" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  result = ((ScXMLLogElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLLogElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLLogElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLLogElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLLogElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLLogElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLLogElt *)new ScXMLLogElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLLogElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLLogElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLLogElt" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_setLabelAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_setLabelAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_setLabelAttribute" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_setLabelAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setLabelAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_getLabelAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_getLabelAttribute" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  result = (char *)((ScXMLLogElt const *)arg1)->getLabelAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_setExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_setExprAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_setExprAttribute" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_setExprAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setExprAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_getExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_getExprAttribute" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  result = (char *)((ScXMLLogElt const *)arg1)->getExprAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_setLevelAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_setLevelAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_setLevelAttribute" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_setLevelAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setLevelAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_getLevelAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_getLevelAttribute" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  result = (char *)((ScXMLLogElt const *)arg1)->getLevelAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_copyContents" "', argument " "1"" of type '" "ScXMLLogElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_search" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLLogElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLLogElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLLogElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLLogElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLLogElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLLogElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLLogElt_execute" "', argument " "1"" of type '" "ScXMLLogElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLLogElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLLogElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLLogElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLLogElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLLogElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLLogElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLMinimumEvaluator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_getTypeId" "', argument " "1"" of type '" "ScXMLMinimumEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  result = ((ScXMLMinimumEvaluator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLMinimumEvaluator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLMinimumEvaluator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLMinimumEvaluator::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLMinimumEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLMinimumEvaluator", 0, 0, 0)) SWIG_fail;
  result = (ScXMLMinimumEvaluator *)new ScXMLMinimumEvaluator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLMinimumEvaluator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLMinimumEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLMinimumEvaluator" "', argument " "1"" of type '" "ScXMLMinimumEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_setStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_setStateMachine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_setStateMachine" "', argument " "1"" of type '" "ScXMLMinimumEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMinimumEvaluator_setStateMachine" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  (arg1)->setStateMachine(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_evaluate" "', argument " "1"" of type '" "ScXMLMinimumEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMinimumEvaluator_evaluate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLMinimumEvaluator const *)arg1)->evaluate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_setAtLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  ScXMLDataObj *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_setAtLocation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_setAtLocation" "', argument " "1"" of type '" "ScXMLMinimumEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMinimumEvaluator_setAtLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLMinimumEvaluator_setAtLocation" "', argument " "3"" of type '" "ScXMLDataObj *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj * >(argp3);
  result = (SbBool)(arg1)->setAtLocation((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_locate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumEvaluator_locate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_locate" "', argument " "1"" of type '" "ScXMLMinimumEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLMinimumEvaluator_locate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLMinimumEvaluator const *)arg1)->locate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumEvaluator_clearTemporaryVariables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumEvaluator_clearTemporaryVariables" "', argument " "1"" of type '" "ScXMLMinimumEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumEvaluator * >(argp1);
  (arg1)->clearTemporaryVariables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLMinimumEvaluator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLMinimumEvaluator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLMinimumEvaluator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLMinimumExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLMinimumExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLMinimumExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLMinimumExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumExprDataObj * >(argp1);
  result = ((ScXMLMinimumExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLMinimumExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLMinimumExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLMinimumExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLMinimumExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLMinimumExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLMinimumExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLMinimumExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLMinimumExprDataObj" "', argument " "1"" of type '" "ScXMLMinimumExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLMinimumExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLMinimumExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLMinimumExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLInExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLInExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInExprDataObj * >(argp1);
  result = ((ScXMLInExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLInExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLInExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLInExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInExprDataObj_createFor" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLDataObj *)ScXMLInExprDataObj::createFor((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLInExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLInExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLInExprDataObj *)new ScXMLInExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLInExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  ScXMLInExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLInExprDataObj" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ScXMLInExprDataObj *)new ScXMLInExprDataObj((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInExprDataObj, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLInExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLInExprDataObj", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLInExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScXMLInExprDataObj__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLInExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLInExprDataObj::ScXMLInExprDataObj()\n"
    "    ScXMLInExprDataObj::ScXMLInExprDataObj(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLInExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLInExprDataObj" "', argument " "1"" of type '" "ScXMLInExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_setStateId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInExprDataObj *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLInExprDataObj_setStateId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInExprDataObj_setStateId" "', argument " "1"" of type '" "ScXMLInExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInExprDataObj * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLInExprDataObj_setStateId" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setStateId((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLInExprDataObj_getStateId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLInExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLInExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLInExprDataObj_getStateId" "', argument " "1"" of type '" "ScXMLInExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLInExprDataObj * >(argp1);
  result = (char *)((ScXMLInExprDataObj const *)arg1)->getStateId();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLInExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLInExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLInExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLAppendOpExprDataObj::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_getTypeId" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  result = ((ScXMLAppendOpExprDataObj const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLAppendOpExprDataObj::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLAppendOpExprDataObj::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLAppendOpExprDataObj::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_createFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_createFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_createFor" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAppendOpExprDataObj_createFor" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLDataObj *)ScXMLAppendOpExprDataObj::createFor(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAppendOpExprDataObj__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ScXMLAppendOpExprDataObj *)new ScXMLAppendOpExprDataObj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAppendOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAppendOpExprDataObj__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ScXMLAppendOpExprDataObj *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScXMLAppendOpExprDataObj" "', argument " "1"" of type '" "ScXMLDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScXMLAppendOpExprDataObj" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  result = (ScXMLAppendOpExprDataObj *)new ScXMLAppendOpExprDataObj(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAppendOpExprDataObj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLAppendOpExprDataObj(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ScXMLAppendOpExprDataObj", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ScXMLAppendOpExprDataObj__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ScXMLDataObj, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ScXMLAppendOpExprDataObj__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ScXMLAppendOpExprDataObj'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLAppendOpExprDataObj::ScXMLAppendOpExprDataObj()\n"
    "    ScXMLAppendOpExprDataObj::ScXMLAppendOpExprDataObj(ScXMLDataObj *,ScXMLDataObj *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLAppendOpExprDataObj(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLAppendOpExprDataObj" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_setLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_setLHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_setLHS" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAppendOpExprDataObj_setLHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setLHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_getLHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_getLHS" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAppendOpExprDataObj const *)arg1)->getLHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_setRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  ScXMLDataObj *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLAppendOpExprDataObj_setRHS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_setRHS" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLAppendOpExprDataObj_setRHS" "', argument " "2"" of type '" "ScXMLDataObj *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataObj * >(argp2);
  (arg1)->setRHS(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLAppendOpExprDataObj_getRHS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLAppendOpExprDataObj *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLAppendOpExprDataObj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLAppendOpExprDataObj_getRHS" "', argument " "1"" of type '" "ScXMLAppendOpExprDataObj const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLAppendOpExprDataObj * >(argp1);
  result = (ScXMLDataObj *)((ScXMLAppendOpExprDataObj const *)arg1)->getRHS();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLAppendOpExprDataObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLAppendOpExprDataObj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLAppendOpExprDataObj_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLOnEntryElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLOnEntryElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_getTypeId" "', argument " "1"" of type '" "ScXMLOnEntryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  result = ((ScXMLOnEntryElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLOnEntryElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLOnEntryElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLOnEntryElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLOnEntryElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLOnEntryElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLOnEntryElt *)new ScXMLOnEntryElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnEntryElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLOnEntryElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLOnEntryElt" "', argument " "1"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_getNumExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_getNumExecutables" "', argument " "1"" of type '" "ScXMLOnEntryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  result = (int)((ScXMLOnEntryElt const *)arg1)->getNumExecutables();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_getExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLExecutableElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_getExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_getExecutable" "', argument " "1"" of type '" "ScXMLOnEntryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLOnEntryElt_getExecutable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLExecutableElt *)((ScXMLOnEntryElt const *)arg1)->getExecutable(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_addExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_addExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_addExecutable" "', argument " "1"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnEntryElt_addExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->addExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_removeExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_removeExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_removeExecutable" "', argument " "1"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnEntryElt_removeExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->removeExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_clearAllExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_clearAllExecutables" "', argument " "1"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  (arg1)->clearAllExecutables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_copyContents" "', argument " "1"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnEntryElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_search" "', argument " "1"" of type '" "ScXMLOnEntryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnEntryElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLOnEntryElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLOnEntryElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnEntryElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnEntryElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnEntryElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnEntryElt_execute" "', argument " "1"" of type '" "ScXMLOnEntryElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnEntryElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnEntryElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLOnEntryElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLOnEntryElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLOnEntryElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLOnEntryElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLOnExitElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLOnExitElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_getTypeId" "', argument " "1"" of type '" "ScXMLOnExitElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  result = ((ScXMLOnExitElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLOnExitElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLOnExitElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLOnExitElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLOnExitElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLOnExitElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLOnExitElt *)new ScXMLOnExitElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnExitElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLOnExitElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLOnExitElt" "', argument " "1"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_getNumExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_getNumExecutables" "', argument " "1"" of type '" "ScXMLOnExitElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  result = (int)((ScXMLOnExitElt const *)arg1)->getNumExecutables();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_getExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLExecutableElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_getExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_getExecutable" "', argument " "1"" of type '" "ScXMLOnExitElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLOnExitElt_getExecutable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLExecutableElt *)((ScXMLOnExitElt const *)arg1)->getExecutable(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_addExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_addExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_addExecutable" "', argument " "1"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnExitElt_addExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->addExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_removeExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_removeExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_removeExecutable" "', argument " "1"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnExitElt_removeExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->removeExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_clearAllExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_clearAllExecutables" "', argument " "1"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  (arg1)->clearAllExecutables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_copyContents" "', argument " "1"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnExitElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_search" "', argument " "1"" of type '" "ScXMLOnExitElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnExitElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLOnExitElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLOnExitElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLOnExitElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLOnExitElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLOnExitElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLOnExitElt_execute" "', argument " "1"" of type '" "ScXMLOnExitElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLOnExitElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLOnExitElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLOnExitElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLOnExitElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLOnExitElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLOnExitElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLParallelElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLParallelElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getTypeId" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = ((ScXMLParallelElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLParallelElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLParallelElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLParallelElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLParallelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLParallelElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLParallelElt *)new ScXMLParallelElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParallelElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLParallelElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLParallelElt" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_setSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_setSrcAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_setSrcAttribute" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_setSrcAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSrcAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getSrcAttribute" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (char *)((ScXMLParallelElt const *)arg1)->getSrcAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_copyContents" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_search" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLParallelElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLParallelElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_setOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLOnEntryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_setOnEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_setOnEntry" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_setOnEntry" "', argument " "2"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnEntryElt * >(argp2);
  (arg1)->setOnEntry(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnEntryElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getOnEntry" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (ScXMLOnEntryElt *)((ScXMLParallelElt const *)arg1)->getOnEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_setOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLOnExitElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_setOnExit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_setOnExit" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_setOnExit" "', argument " "2"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnExitElt * >(argp2);
  (arg1)->setOnExit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnExitElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getOnExit" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (ScXMLOnExitElt *)((ScXMLParallelElt const *)arg1)->getOnExit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumTransitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumTransitions" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumTransitions();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLTransitionElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getTransition" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getTransition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLTransitionElt *)((ScXMLParallelElt const *)arg1)->getTransition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addTransition" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->addTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeTransition" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->removeTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllTransitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllTransitions" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllTransitions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_setInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLInitialElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_setInitial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_setInitial" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_setInitial" "', argument " "2"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLInitialElt * >(argp2);
  (arg1)->setInitial(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLInitialElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getInitial" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (ScXMLInitialElt *)((ScXMLParallelElt const *)arg1)->getInitial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumStates" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumStates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLStateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getState" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLStateElt *)((ScXMLParallelElt const *)arg1)->getState(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addState" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->addState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeState" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->removeState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllStates" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllStates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumParallels" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumParallels();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLParallelElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getParallel" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getParallel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLParallelElt *)((ScXMLParallelElt const *)arg1)->getParallel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addParallel" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->addParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeParallel" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->removeParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllParallels" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllParallels();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumFinals" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumFinals();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLFinalElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getFinal" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getFinal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLFinalElt *)((ScXMLParallelElt const *)arg1)->getFinal(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addFinal" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->addFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeFinal" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->removeFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllFinals" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllFinals();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumHistories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumHistories" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumHistories();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLHistoryElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getHistory" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getHistory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLHistoryElt *)((ScXMLParallelElt const *)arg1)->getHistory(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLHistoryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addHistory" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addHistory" "', argument " "2"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLHistoryElt * >(argp2);
  (arg1)->addHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLHistoryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeHistory" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeHistory" "', argument " "2"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLHistoryElt * >(argp2);
  (arg1)->removeHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllHistories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllHistories" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllHistories();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getNumAnchors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getNumAnchors" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (int)((ScXMLParallelElt const *)arg1)->getNumAnchors();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLAnchorElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_getAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getAnchor" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLParallelElt_getAnchor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLAnchorElt *)((ScXMLParallelElt const *)arg1)->getAnchor(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_addAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLAnchorElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_addAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_addAnchor" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_addAnchor" "', argument " "2"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLAnchorElt * >(argp2);
  (arg1)->addAnchor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_removeAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLAnchorElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_removeAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_removeAnchor" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_removeAnchor" "', argument " "2"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLAnchorElt * >(argp2);
  (arg1)->removeAnchor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_clearAllAnchors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_clearAllAnchors" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  (arg1)->clearAllAnchors();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_setDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  ScXMLDataModelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParallelElt_setDataModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_setDataModel" "', argument " "1"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParallelElt_setDataModel" "', argument " "2"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataModelElt * >(argp2);
  (arg1)->setDataModel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_getDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataModelElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_getDataModel" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (ScXMLDataModelElt *)((ScXMLParallelElt const *)arg1)->getDataModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParallelElt_isAtomicState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParallelElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParallelElt_isAtomicState" "', argument " "1"" of type '" "ScXMLParallelElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParallelElt * >(argp1);
  result = (SbBool)((ScXMLParallelElt const *)arg1)->isAtomicState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLParallelElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLParallelElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLParallelElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLParamElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLParamElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLParamElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_getTypeId" "', argument " "1"" of type '" "ScXMLParamElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  result = ((ScXMLParamElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLParamElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLParamElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLParamElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLParamElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLParamElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLParamElt *)new ScXMLParamElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParamElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLParamElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLParamElt" "', argument " "1"" of type '" "ScXMLParamElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_setNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_setNameAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_setNameAttribute" "', argument " "1"" of type '" "ScXMLParamElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParamElt_setNameAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setNameAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_getNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_getNameAttribute" "', argument " "1"" of type '" "ScXMLParamElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  result = (char *)((ScXMLParamElt const *)arg1)->getNameAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_setExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_setExprAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_setExprAttribute" "', argument " "1"" of type '" "ScXMLParamElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParamElt_setExprAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setExprAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_getExprAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_getExprAttribute" "', argument " "1"" of type '" "ScXMLParamElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  result = (char *)((ScXMLParamElt const *)arg1)->getExprAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLParamElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_copyContents" "', argument " "1"" of type '" "ScXMLParamElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParamElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLParamElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLParamElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLParamElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLParamElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLParamElt_search" "', argument " "1"" of type '" "ScXMLParamElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLParamElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLParamElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLParamElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLParamElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *ScXMLParamElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLParamElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLParamElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLScriptElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLScriptElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLScriptElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScriptElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScriptElt_getTypeId" "', argument " "1"" of type '" "ScXMLScriptElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScriptElt * >(argp1);
  result = ((ScXMLScriptElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLScriptElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLScriptElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLScriptElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLScriptElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScriptElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLScriptElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLScriptElt *)new ScXMLScriptElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLScriptElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLScriptElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScriptElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScriptElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLScriptElt" "', argument " "1"" of type '" "ScXMLScriptElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScriptElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScriptElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScriptElt_copyContents" "', argument " "1"" of type '" "ScXMLScriptElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScriptElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScriptElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScriptElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScriptElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScriptElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScriptElt_execute" "', argument " "1"" of type '" "ScXMLScriptElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScriptElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScriptElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLScriptElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLScriptElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLScriptElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLScriptElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLScxmlElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLScxmlElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getTypeId" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = ((ScXMLScxmlElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLScxmlElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLScxmlElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLScxmlElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLScxmlElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLScxmlElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLScxmlElt *)new ScXMLScxmlElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLScxmlElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLScxmlElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLScxmlElt" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setIsReferenced(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  SbBool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setIsReferenced", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setIsReferenced" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLScxmlElt_setIsReferenced" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setIsReferenced(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_isReferenced(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_isReferenced" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (SbBool)((ScXMLScxmlElt const *)arg1)->isReferenced();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setInitialAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setInitialAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setInitialAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setInitialAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setInitialAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getInitialAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getInitialAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getInitialAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setNameAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setNameAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setNameAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setNameAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getNameAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getNameAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getNameAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setXMLNSAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setXMLNSAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setXMLNSAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setXMLNSAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setXMLNSAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getXMLNSAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getXMLNSAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getXMLNSAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setVersionAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setVersionAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setVersionAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setVersionAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setVersionAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getVersionAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getVersionAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getVersionAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setProfileAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setProfileAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setProfileAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setProfileAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setProfileAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getProfileAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getProfileAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getProfileAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setExModeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setExModeAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setExModeAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setExModeAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setExModeAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getExModeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getExModeAttribute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (char *)((ScXMLScxmlElt const *)arg1)->getExModeAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_copyContents" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_search" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLScxmlElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLScxmlElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLInitialElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setInitial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setInitial" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setInitial" "', argument " "2"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLInitialElt * >(argp2);
  (arg1)->setInitial(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLInitialElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getInitial" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (ScXMLInitialElt *)((ScXMLScxmlElt const *)arg1)->getInitial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getNumStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getNumStates" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (int)((ScXMLScxmlElt const *)arg1)->getNumStates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLStateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getState" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLScxmlElt_getState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLStateElt *)((ScXMLScxmlElt const *)arg1)->getState(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_addState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_addState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_addState" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_addState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->addState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_removeState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_removeState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_removeState" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_removeState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->removeState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_clearAllStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_clearAllStates" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  (arg1)->clearAllStates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getNumParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getNumParallels" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (int)((ScXMLScxmlElt const *)arg1)->getNumParallels();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLParallelElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getParallel" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLScxmlElt_getParallel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLParallelElt *)((ScXMLScxmlElt const *)arg1)->getParallel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_addParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_addParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_addParallel" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_addParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->addParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_removeParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_removeParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_removeParallel" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_removeParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->removeParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_clearAllParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_clearAllParallels" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  (arg1)->clearAllParallels();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getNumFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getNumFinals" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (int)((ScXMLScxmlElt const *)arg1)->getNumFinals();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLFinalElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getFinal" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLScxmlElt_getFinal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLFinalElt *)((ScXMLScxmlElt const *)arg1)->getFinal(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_addFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_addFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_addFinal" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_addFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->addFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_removeFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_removeFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_removeFinal" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_removeFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->removeFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_clearAllFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_clearAllFinals" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  (arg1)->clearAllFinals();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_setDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLDataModelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_setDataModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_setDataModel" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_setDataModel" "', argument " "2"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataModelElt * >(argp2);
  (arg1)->setDataModel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataModelElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getDataModel" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (ScXMLDataModelElt *)((ScXMLScxmlElt const *)arg1)->getDataModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getNumScripts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getNumScripts" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  result = (int)((ScXMLScxmlElt const *)arg1)->getNumScripts();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_getScript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLScriptElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_getScript", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_getScript" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLScxmlElt_getScript" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLScriptElt *)((ScXMLScxmlElt const *)arg1)->getScript(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_addScript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLScriptElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_addScript", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_addScript" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_addScript" "', argument " "2"" of type '" "ScXMLScriptElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLScriptElt * >(argp2);
  (arg1)->addScript(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_removeScript(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLScriptElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_removeScript", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_removeScript" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLScriptElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_removeScript" "', argument " "2"" of type '" "ScXMLScriptElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLScriptElt * >(argp2);
  (arg1)->removeScript(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_clearAllScripts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_clearAllScripts" "', argument " "1"" of type '" "ScXMLScxmlElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  (arg1)->clearAllScripts();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLScxmlElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLScxmlElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLScxmlElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLScxmlElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLScxmlElt_execute" "', argument " "1"" of type '" "ScXMLScxmlElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLScxmlElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLScxmlElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLScxmlElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLScxmlElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLScxmlElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLScxmlElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLSendElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLSendElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLSendElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getTypeId" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = ((ScXMLSendElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLSendElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLSendElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLSendElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLSendElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLSendElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLSendElt *)new ScXMLSendElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLSendElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLSendElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLSendElt" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setEventAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setEventAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setEventAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setEventAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setEventAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getEventAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getEventAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getEventAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setTargetAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setTargetAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setTargetAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setTargetAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTargetAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getTargetAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getTargetAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getTargetAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setTargetTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setTargetTypeAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setTargetTypeAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setTargetTypeAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTargetTypeAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getTargetTypeAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getTargetTypeAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getTargetTypeAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setSendIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setSendIDAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setSendIDAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setSendIDAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSendIDAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getSendIDAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getSendIDAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getSendIDAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setDelayAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setDelayAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setDelayAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setDelayAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setDelayAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getDelayAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getDelayAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getDelayAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setNameListAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setNameListAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setNameListAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setNameListAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setNameListAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getNameListAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getNameListAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getNameListAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_setHintsAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_setHintsAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_setHintsAttribute" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_setHintsAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setHintsAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_getHintsAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_getHintsAttribute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (char *)((ScXMLSendElt const *)arg1)->getHintsAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_copyContents" "', argument " "1"" of type '" "ScXMLSendElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_search" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLSendElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLSendElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_createEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  ScXMLEventTarget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_createEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_createEvent" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEventTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_createEvent" "', argument " "2"" of type '" "ScXMLEventTarget *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEventTarget * >(argp2);
  result = (ScXMLEvent *)((ScXMLSendElt const *)arg1)->createEvent(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLSendElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLSendElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLSendElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLSendElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLSendElt_execute" "', argument " "1"" of type '" "ScXMLSendElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLSendElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLSendElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLSendElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLSendElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLSendElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLSendElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLStateElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLStateElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLStateElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getTypeId" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = ((ScXMLStateElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLStateElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLStateElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLStateElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLStateElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLStateElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLStateElt *)new ScXMLStateElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLStateElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLStateElt" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setSrcAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setSrcAttribute" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setSrcAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSrcAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getSrcAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getSrcAttribute" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (char *)((ScXMLStateElt const *)arg1)->getSrcAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setInitialAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setInitialAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setInitialAttribute" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setInitialAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setInitialAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getInitialAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getInitialAttribute" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (char *)((ScXMLStateElt const *)arg1)->getInitialAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_copyContents" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_search" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLStateElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLOnEntryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setOnEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setOnEntry" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setOnEntry" "', argument " "2"" of type '" "ScXMLOnEntryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnEntryElt * >(argp2);
  (arg1)->setOnEntry(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getOnEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnEntryElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getOnEntry" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (ScXMLOnEntryElt *)((ScXMLStateElt const *)arg1)->getOnEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnEntryElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLOnExitElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setOnExit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setOnExit" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setOnExit" "', argument " "2"" of type '" "ScXMLOnExitElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLOnExitElt * >(argp2);
  (arg1)->setOnExit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getOnExit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLOnExitElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getOnExit" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (ScXMLOnExitElt *)((ScXMLStateElt const *)arg1)->getOnExit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLOnExitElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumTransitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumTransitions" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumTransitions();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLTransitionElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getTransition" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getTransition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLTransitionElt *)((ScXMLStateElt const *)arg1)->getTransition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addTransition" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->addTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeTransition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLTransitionElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeTransition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeTransition" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeTransition" "', argument " "2"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLTransitionElt * >(argp2);
  (arg1)->removeTransition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllTransitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllTransitions" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllTransitions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLInitialElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setInitial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setInitial" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setInitial" "', argument " "2"" of type '" "ScXMLInitialElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLInitialElt * >(argp2);
  (arg1)->setInitial(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getInitial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLInitialElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getInitial" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (ScXMLInitialElt *)((ScXMLStateElt const *)arg1)->getInitial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLInitialElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumStates" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumStates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLStateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getState" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLStateElt *)((ScXMLStateElt const *)arg1)->getState(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addState" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->addState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLStateElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeState" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeState" "', argument " "2"" of type '" "ScXMLStateElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateElt * >(argp2);
  (arg1)->removeState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllStates" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllStates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumParallels" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumParallels();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLParallelElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getParallel" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getParallel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLParallelElt *)((ScXMLStateElt const *)arg1)->getParallel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addParallel" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->addParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeParallel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLParallelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeParallel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeParallel" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLParallelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeParallel" "', argument " "2"" of type '" "ScXMLParallelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLParallelElt * >(argp2);
  (arg1)->removeParallel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllParallels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllParallels" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllParallels();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumFinals" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumFinals();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLFinalElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getFinal" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getFinal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLFinalElt *)((ScXMLStateElt const *)arg1)->getFinal(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addFinal" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->addFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeFinal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLFinalElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeFinal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeFinal" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLFinalElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeFinal" "', argument " "2"" of type '" "ScXMLFinalElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLFinalElt * >(argp2);
  (arg1)->removeFinal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllFinals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllFinals" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllFinals();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumHistories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumHistories" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumHistories();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLHistoryElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getHistory" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getHistory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLHistoryElt *)((ScXMLStateElt const *)arg1)->getHistory(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLHistoryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addHistory" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addHistory" "', argument " "2"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLHistoryElt * >(argp2);
  (arg1)->addHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLHistoryElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeHistory" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLHistoryElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeHistory" "', argument " "2"" of type '" "ScXMLHistoryElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLHistoryElt * >(argp2);
  (arg1)->removeHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllHistories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllHistories" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllHistories();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getNumAnchors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getNumAnchors" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (int)((ScXMLStateElt const *)arg1)->getNumAnchors();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLAnchorElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_getAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getAnchor" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateElt_getAnchor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLAnchorElt *)((ScXMLStateElt const *)arg1)->getAnchor(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_addAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLAnchorElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_addAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_addAnchor" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_addAnchor" "', argument " "2"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLAnchorElt * >(argp2);
  (arg1)->addAnchor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_removeAnchor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLAnchorElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_removeAnchor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_removeAnchor" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLAnchorElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_removeAnchor" "', argument " "2"" of type '" "ScXMLAnchorElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLAnchorElt * >(argp2);
  (arg1)->removeAnchor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_clearAllAnchors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_clearAllAnchors" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  (arg1)->clearAllAnchors();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_setDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  ScXMLDataModelElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateElt_setDataModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_setDataModel" "', argument " "1"" of type '" "ScXMLStateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateElt_setDataModel" "', argument " "2"" of type '" "ScXMLDataModelElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDataModelElt * >(argp2);
  (arg1)->setDataModel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_getDataModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDataModelElt *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_getDataModel" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (ScXMLDataModelElt *)((ScXMLStateElt const *)arg1)->getDataModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataModelElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateElt_isAtomicState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateElt_isAtomicState" "', argument " "1"" of type '" "ScXMLStateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateElt * >(argp1);
  result = (SbBool)((ScXMLStateElt const *)arg1)->isAtomicState();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLStateElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLStateElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLStateElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLStateMachine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getTypeId" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = ((ScXMLStateMachine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLStateMachine::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLStateMachine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLStateMachine::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLStateMachine", 0, 0, 0)) SWIG_fail;
  result = (ScXMLStateMachine *)new ScXMLStateMachine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateMachine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLStateMachine" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setName" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setName((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getName" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (SbName *) &((ScXMLStateMachine const *)arg1)->getName();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLDocument *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setDescription" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_setDescription" "', argument " "2"" of type '" "ScXMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLDocument * >(argp2);
  (arg1)->setDescription(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLDocument *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getDescription" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (ScXMLDocument *)((ScXMLStateMachine const *)arg1)->getDescription();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setSessionId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  SbName *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setSessionId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setSessionId" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (PyBytes_Check(swig_obj[1]))
    {
      arg2 = new SbName(PyBytes_AsString(swig_obj[1]));
    }
    else if  (PyUnicode_Check(swig_obj[1])){
      arg2 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[1], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg2 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[1], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg2 = *tmp;
    }
  }
  (arg1)->setSessionId((SbName const &)*arg2);
  resultobj = SWIG_Py_Void();
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return resultobj;
fail:
  {
    if (arg2) {
      delete arg2; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getSessionId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbName *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getSessionId" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (SbName *) &((ScXMLStateMachine const *)arg1)->getSessionId();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbName, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_initialize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_initialize" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  (arg1)->initialize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_isActive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_isActive" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (SbBool)((ScXMLStateMachine const *)arg1)->isActive();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_isFinished(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_isFinished" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (SbBool)((ScXMLStateMachine const *)arg1)->isFinished();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getNumActiveStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getNumActiveStates" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (int)((ScXMLStateMachine const *)arg1)->getNumActiveStates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getActiveState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_getActiveState", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getActiveState" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateMachine_getActiveState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLElt *)((ScXMLStateMachine const *)arg1)->getActiveState(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addDeleteCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLStateMachineDeleteCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_addDeleteCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ScXMLStateMachine_addDeleteCallback" "', argument " "2"" of type '" "ScXMLStateMachineDeleteCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateMachine_addDeleteCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addDeleteCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeDeleteCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLStateMachineDeleteCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_removeDeleteCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ScXMLStateMachine_removeDeleteCallback" "', argument " "2"" of type '" "ScXMLStateMachineDeleteCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateMachine_removeDeleteCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeDeleteCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addStateChangeCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLStateChangeCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_addStateChangeCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ScXMLStateMachine_addStateChangeCallback" "', argument " "2"" of type '" "ScXMLStateChangeCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateMachine_addStateChangeCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->addStateChangeCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeStateChangeCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLStateChangeCB *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_removeStateChangeCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ScXMLStateMachine_removeStateChangeCallback" "', argument " "2"" of type '" "ScXMLStateChangeCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateMachine_removeStateChangeCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->removeStateChangeCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setVariable", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setVariable" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_setVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLStateMachine_setVariable" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->setVariable((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_getVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getVariable" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_getVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (char *)((ScXMLStateMachine const *)arg1)->getVariable((char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getStateMachineForSessionId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbName *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyBytes_Check(swig_obj[0]))
    {
      arg1 = new SbName(PyBytes_AsString(swig_obj[0]));
    }
    else if  (PyUnicode_Check(swig_obj[0])){
      arg1 = new SbName(PyBytes_AsString(PyUnicode_AsEncodedString(swig_obj[0], "utf-8", "Error ~")));
    }
    
    else {
      SbName * tmp = NULL;
      arg1 = new SbName;
      
      
      
      SWIG_ConvertPtr(swig_obj[0], (void**)&tmp,  SWIGTYPE_p_SbName, 1);
      
      *arg1 = *tmp;
    }
  }
  result = (ScXMLStateMachine *)ScXMLStateMachine::getStateMachineForSessionId((SbName const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return resultobj;
fail:
  {
    if (arg1) {
      delete arg1; 
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setLogLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setLogLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setLogLevel" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateMachine_setLogLevel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setLogLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getLogLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getLogLevel" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (int)((ScXMLStateMachine const *)arg1)->getLogLevel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  ScXMLEvaluator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setEvaluator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setEvaluator" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_setEvaluator" "', argument " "2"" of type '" "ScXMLEvaluator *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEvaluator * >(argp2);
  (arg1)->setEvaluator(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ScXMLEvaluator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getEvaluator" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (ScXMLEvaluator *)((ScXMLStateMachine const *)arg1)->getEvaluator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEvaluator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_isModuleEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_isModuleEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_isModuleEnabled" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_isModuleEnabled" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SbBool)((ScXMLStateMachine const *)arg1)->isModuleEnabled((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getNumEnabledModules(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getNumEnabledModules" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  result = (int)((ScXMLStateMachine const *)arg1)->getNumEnabledModules();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_getEnabledModuleName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_getEnabledModuleName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_getEnabledModuleName" "', argument " "1"" of type '" "ScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLStateMachine_getEnabledModuleName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((ScXMLStateMachine const *)arg1)->getEnabledModuleName(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_setEnabledModulesList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  SbList< char const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_setEnabledModulesList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_setEnabledModulesList" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbListT_char_const_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLStateMachine_setEnabledModulesList" "', argument " "2"" of type '" "SbList< char const * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ScXMLStateMachine_setEnabledModulesList" "', argument " "2"" of type '" "SbList< char const * > const &""'"); 
  }
  arg2 = reinterpret_cast< SbList< char const * > * >(argp2);
  (arg1)->setEnabledModulesList((SbList< char const * > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addDeleteCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_addDeleteCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  ScXMLStateMachine_addDeleteCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addDeleteCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_addDeleteCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ScXMLStateMachine_addDeleteCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ScXMLStateMachine_addDeleteCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLStateMachine_addDeleteCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLStateMachine::addDeleteCallback(ScXMLStateMachineDeleteCB *,void *)\n"
    "    ScXMLStateMachine::addDeleteCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeDeleteCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_removeDeleteCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  ScXMLStateMachine_removeDeleteCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeDeleteCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_removeDeleteCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ScXMLStateMachine_removeDeleteCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ScXMLStateMachine_removeDeleteCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLStateMachine_removeDeleteCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLStateMachine::removeDeleteCallback(ScXMLStateMachineDeleteCB *,void *)\n"
    "    ScXMLStateMachine::removeDeleteCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addStateChangeCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_addStateChangeCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  ScXMLStateMachine_addStateChangeCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_addStateChangeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_addStateChangeCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ScXMLStateMachine_addStateChangeCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ScXMLStateMachine_addStateChangeCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLStateMachine_addStateChangeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLStateMachine::addStateChangeCallback(ScXMLStateChangeCB *,void *)\n"
    "    ScXMLStateMachine::addStateChangeCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeStateChangeCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ScXMLStateMachine *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLStateMachine_removeStateChangeCallback" "', argument " "1"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLStateMachine * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  arg3 = swig_obj[2];
  ScXMLStateMachine_removeStateChangeCallback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLStateMachine_removeStateChangeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ScXMLStateMachine_removeStateChangeCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ScXMLStateMachine_removeStateChangeCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ScXMLStateMachine, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_ScXMLStateMachine_removeStateChangeCallback__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScXMLStateMachine_removeStateChangeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ScXMLStateMachine::removeStateChangeCallback(ScXMLStateChangeCB *,void *)\n"
    "    ScXMLStateMachine::removeStateChangeCallback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *ScXMLStateMachine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLStateMachine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLStateMachine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLTransitionElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLTransitionElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getTypeId" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = ((ScXMLTransitionElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLTransitionElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLTransitionElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLTransitionElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLTransitionElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLTransitionElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLTransitionElt *)new ScXMLTransitionElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLTransitionElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLTransitionElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLTransitionElt" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_setEventAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_setEventAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_setEventAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_setEventAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setEventAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getEventAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getEventAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (char *)((ScXMLTransitionElt const *)arg1)->getEventAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_setCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_setCondAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_setCondAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_setCondAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setCondAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getCondAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getCondAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (char *)((ScXMLTransitionElt const *)arg1)->getCondAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_setTargetAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_setTargetAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_setTargetAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_setTargetAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTargetAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getTargetAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getTargetAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (char *)((ScXMLTransitionElt const *)arg1)->getTargetAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_setAnchorAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_setAnchorAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_setAnchorAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_setAnchorAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setAnchorAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getAnchorAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getAnchorAttribute" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (char *)((ScXMLTransitionElt const *)arg1)->getAnchorAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_copyContents" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_search" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLTransitionElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLTransitionElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_isConditionLess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_isConditionLess" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (SbBool)((ScXMLTransitionElt const *)arg1)->isConditionLess();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_isTargetLess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_isTargetLess" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (SbBool)((ScXMLTransitionElt const *)arg1)->isTargetLess();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_isSelfReferencing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_isSelfReferencing" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (SbBool)((ScXMLTransitionElt const *)arg1)->isSelfReferencing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_isEventMatch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_isEventMatch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_isEventMatch" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_isEventMatch" "', argument " "2"" of type '" "ScXMLEvent const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEvent * >(argp2);
  result = (SbBool)((ScXMLTransitionElt const *)arg1)->isEventMatch((ScXMLEvent const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_evaluateCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_evaluateCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_evaluateCondition" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_evaluateCondition" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  result = (SbBool)(arg1)->evaluateCondition(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getNumExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getNumExecutables" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  result = (int)((ScXMLTransitionElt const *)arg1)->getNumExecutables();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_getExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLExecutableElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_getExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_getExecutable" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScXMLTransitionElt_getExecutable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ScXMLExecutableElt *)((ScXMLTransitionElt const *)arg1)->getExecutable(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_addExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_addExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_addExecutable" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_addExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->addExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_removeExecutable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLExecutableElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_removeExecutable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_removeExecutable" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLExecutableElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_removeExecutable" "', argument " "2"" of type '" "ScXMLExecutableElt *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLExecutableElt * >(argp2);
  (arg1)->removeExecutable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_clearAllExecutables(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_clearAllExecutables" "', argument " "1"" of type '" "ScXMLTransitionElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  (arg1)->clearAllExecutables();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLTransitionElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLTransitionElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLTransitionElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLTransitionElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLTransitionElt_execute" "', argument " "1"" of type '" "ScXMLTransitionElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLTransitionElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLTransitionElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLTransitionElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLTransitionElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLTransitionElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLTransitionElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLValidateElt_getElementReader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLEltReader *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_getElementReader", 0, 0, 0)) SWIG_fail;
  result = (ScXMLEltReader *)ScXMLValidateElt::getElementReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLEltReader, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLValidateElt::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_getTypeId" "', argument " "1"" of type '" "ScXMLValidateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  result = ((ScXMLValidateElt const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLValidateElt::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLValidateElt::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLValidateElt::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLValidateElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLValidateElt", 0, 0, 0)) SWIG_fail;
  result = (ScXMLValidateElt *)new ScXMLValidateElt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLValidateElt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLValidateElt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLValidateElt" "', argument " "1"" of type '" "ScXMLValidateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_setLocationAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_setLocationAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_setLocationAttribute" "', argument " "1"" of type '" "ScXMLValidateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLValidateElt_setLocationAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setLocationAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_getLocationAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_getLocationAttribute" "', argument " "1"" of type '" "ScXMLValidateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  result = (char *)((ScXMLValidateElt const *)arg1)->getLocationAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_setSchemaAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_setSchemaAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_setSchemaAttribute" "', argument " "1"" of type '" "ScXMLValidateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLValidateElt_setSchemaAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setSchemaAttribute((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_getSchemaAttribute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_getSchemaAttribute" "', argument " "1"" of type '" "ScXMLValidateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  result = (char *)((ScXMLValidateElt const *)arg1)->getSchemaAttribute();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_handleXMLAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbBool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_handleXMLAttributes" "', argument " "1"" of type '" "ScXMLValidateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  result = (SbBool)(arg1)->handleXMLAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  ScXMLElt *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_copyContents" "', argument " "1"" of type '" "ScXMLValidateElt *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLValidateElt_copyContents" "', argument " "2"" of type '" "ScXMLElt const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLElt * >(argp2);
  (arg1)->copyContents((ScXMLElt const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_search(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  ScXMLElt *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_search", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_search" "', argument " "1"" of type '" "ScXMLValidateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLValidateElt_search" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLValidateElt_search" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (ScXMLElt *)((ScXMLValidateElt const *)arg1)->search((char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLElt, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLValidateElt_execute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLValidateElt *arg1 = 0 ;
  ScXMLStateMachine *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLValidateElt_execute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLValidateElt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLValidateElt_execute" "', argument " "1"" of type '" "ScXMLValidateElt const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLValidateElt * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLValidateElt_execute" "', argument " "2"" of type '" "ScXMLStateMachine *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLStateMachine * >(argp2);
  ((ScXMLValidateElt const *)arg1)->execute(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScXMLValidateElt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLValidateElt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLValidateElt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = ScXMLXPathEvaluator::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXPathEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXPathEvaluator_getTypeId" "', argument " "1"" of type '" "ScXMLXPathEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXPathEvaluator * >(argp1);
  result = ((ScXMLXPathEvaluator const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)ScXMLXPathEvaluator::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_initClass", 0, 0, 0)) SWIG_fail;
  ScXMLXPathEvaluator::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_cleanClass", 0, 0, 0)) SWIG_fail;
  ScXMLXPathEvaluator::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScXMLXPathEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ScXMLXPathEvaluator", 0, 0, 0)) SWIG_fail;
  result = (ScXMLXPathEvaluator *)new ScXMLXPathEvaluator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLXPathEvaluator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScXMLXPathEvaluator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXPathEvaluator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScXMLXPathEvaluator" "', argument " "1"" of type '" "ScXMLXPathEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXPathEvaluator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_evaluate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_evaluate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXPathEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXPathEvaluator_evaluate" "', argument " "1"" of type '" "ScXMLXPathEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXPathEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLXPathEvaluator_evaluate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLXPathEvaluator const *)arg1)->evaluate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_setAtLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  ScXMLDataObj *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_setAtLocation", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXPathEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXPathEvaluator_setAtLocation" "', argument " "1"" of type '" "ScXMLXPathEvaluator *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXPathEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLXPathEvaluator_setAtLocation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScXMLXPathEvaluator_setAtLocation" "', argument " "3"" of type '" "ScXMLDataObj *""'"); 
  }
  arg3 = reinterpret_cast< ScXMLDataObj * >(argp3);
  result = (SbBool)(arg1)->setAtLocation((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScXMLXPathEvaluator_locate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ScXMLXPathEvaluator *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  ScXMLDataObj *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ScXMLXPathEvaluator_locate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScXMLXPathEvaluator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScXMLXPathEvaluator_locate" "', argument " "1"" of type '" "ScXMLXPathEvaluator const *""'"); 
  }
  arg1 = reinterpret_cast< ScXMLXPathEvaluator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScXMLXPathEvaluator_locate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ScXMLDataObj *)((ScXMLXPathEvaluator const *)arg1)->locate((char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScXMLDataObj, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *ScXMLXPathEvaluator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ScXMLXPathEvaluator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ScXMLXPathEvaluator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScXMLEvent_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLEvent::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLEvent_getTypeId" "', argument " "1"" of type '" "SoScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  result = ((SoScXMLEvent const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLEvent::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLEvent::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLEvent::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScXMLEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScXMLEvent", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLEvent *)new SoScXMLEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoScXMLEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoScXMLEvent" "', argument " "1"" of type '" "SoScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_setSoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  SoEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_setSoEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLEvent_setSoEvent" "', argument " "1"" of type '" "SoScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLEvent_setSoEvent" "', argument " "2"" of type '" "SoEvent const *""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  (arg1)->setSoEvent((SoEvent const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_getSoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLEvent_getSoEvent" "', argument " "1"" of type '" "SoScXMLEvent const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  result = (SoEvent *)((SoScXMLEvent const *)arg1)->getSoEvent();
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_setUpIdentifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLEvent_setUpIdentifier" "', argument " "1"" of type '" "SoScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  (arg1)->setUpIdentifier();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLEvent_copyContents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLEvent *arg1 = 0 ;
  ScXMLEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLEvent_copyContents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLEvent_copyContents" "', argument " "1"" of type '" "SoScXMLEvent *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLEvent * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScXMLEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLEvent_copyContents" "', argument " "2"" of type '" "ScXMLEvent const *""'"); 
  }
  arg2 = reinterpret_cast< ScXMLEvent * >(argp2);
  (arg1)->copyContents((ScXMLEvent const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoScXMLEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScXMLEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getClassTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_getClassTypeId", 0, 0, 0)) SWIG_fail;
  result = SoScXMLStateMachine::getClassTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getTypeId(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoType result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_getTypeId" "', argument " "1"" of type '" "SoScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  result = ((SoScXMLStateMachine const *)arg1)->getTypeId();
  resultobj = SWIG_NewPointerObj((new SoType(result)), SWIGTYPE_p_SoType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoScXMLStateMachine::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_initClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_initClass", 0, 0, 0)) SWIG_fail;
  SoScXMLStateMachine::initClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_cleanClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_cleanClass", 0, 0, 0)) SWIG_fail;
  SoScXMLStateMachine::cleanClass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SoScXMLStateMachine", 0, 0, 0)) SWIG_fail;
  result = (SoScXMLStateMachine *)new SoScXMLStateMachine();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoScXMLStateMachine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoScXMLStateMachine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoScXMLStateMachine" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_setSceneGraphRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  SoNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_setSceneGraphRoot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_setSceneGraphRoot" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLStateMachine_setSceneGraphRoot" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraphRoot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getSceneGraphRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoNode *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_getSceneGraphRoot" "', argument " "1"" of type '" "SoScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  result = (SoNode *)((SoScXMLStateMachine const *)arg1)->getSceneGraphRoot();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_setActiveCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  SoCamera *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_setActiveCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_setActiveCamera" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoCamera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLStateMachine_setActiveCamera" "', argument " "2"" of type '" "SoCamera *""'"); 
  }
  arg2 = reinterpret_cast< SoCamera * >(argp2);
  (arg1)->setActiveCamera(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getActiveCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoCamera *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_getActiveCamera" "', argument " "1"" of type '" "SoScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  result = (SoCamera *)((SoScXMLStateMachine const *)arg1)->getActiveCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  SbViewportRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_setViewportRegion" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbViewportRegion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLStateMachine_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoScXMLStateMachine_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  arg2 = reinterpret_cast< SbViewportRegion * >(argp2);
  (arg1)->setViewportRegion((SbViewportRegion const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SbViewportRegion *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_getViewportRegion" "', argument " "1"" of type '" "SoScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  result = (SbViewportRegion *) &((SoScXMLStateMachine const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_preGLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_preGLRender" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  (arg1)->preGLRender();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_postGLRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_postGLRender" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  (arg1)->postGLRender();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_processSoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  SoEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_processSoEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_processSoEvent" "', argument " "1"" of type '" "SoScXMLStateMachine *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLStateMachine_processSoEvent" "', argument " "2"" of type '" "SoEvent const *""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  result = (SbBool)(arg1)->processSoEvent((SoEvent const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoScXMLStateMachine_getVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoScXMLStateMachine *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoScXMLStateMachine_getVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoScXMLStateMachine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoScXMLStateMachine_getVariable" "', argument " "1"" of type '" "SoScXMLStateMachine const *""'"); 
  }
  arg1 = reinterpret_cast< SoScXMLStateMachine * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoScXMLStateMachine_getVariable" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (char *)((SoScXMLStateMachine const *)arg1)->getVariable((char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *SoScXMLStateMachine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SoScXMLStateMachine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoScXMLStateMachine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "cast", cast, METH_VARARGS, NULL},
	 { "new_charp", _wrap_new_charp, METH_NOARGS, "new_charp() -> charp"},
	 { "delete_charp", _wrap_delete_charp, METH_O, "delete_charp(charp self)"},
	 { "charp_assign", _wrap_charp_assign, METH_VARARGS, "charp_assign(charp self, char value)"},
	 { "charp_value", _wrap_charp_value, METH_O, "charp_value(charp self) -> char"},
	 { "charp_cast", _wrap_charp_cast, METH_O, "charp_cast(charp self) -> char *"},
	 { "charp_frompointer", _wrap_charp_frompointer, METH_O, "charp_frompointer(char * t) -> charp"},
	 { "charp_swigregister", charp_swigregister, METH_O, NULL},
	 { "charp_swiginit", charp_swiginit, METH_VARARGS, NULL},
	 { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"},
	 { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"},
	 { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"},
	 { "intp_value", _wrap_intp_value, METH_O, "intp_value(intp self) -> int"},
	 { "intp_cast", _wrap_intp_cast, METH_O, "intp_cast(intp self) -> int *"},
	 { "intp_frompointer", _wrap_intp_frompointer, METH_O, "intp_frompointer(int * t) -> intp"},
	 { "intp_swigregister", intp_swigregister, METH_O, NULL},
	 { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL},
	 { "new_longp", _wrap_new_longp, METH_NOARGS, "new_longp() -> longp"},
	 { "delete_longp", _wrap_delete_longp, METH_O, "delete_longp(longp self)"},
	 { "longp_assign", _wrap_longp_assign, METH_VARARGS, "longp_assign(longp self, long value)"},
	 { "longp_value", _wrap_longp_value, METH_O, "longp_value(longp self) -> long"},
	 { "longp_cast", _wrap_longp_cast, METH_O, "longp_cast(longp self) -> long *"},
	 { "longp_frompointer", _wrap_longp_frompointer, METH_O, "longp_frompointer(long * t) -> longp"},
	 { "longp_swigregister", longp_swigregister, METH_O, NULL},
	 { "longp_swiginit", longp_swiginit, METH_VARARGS, NULL},
	 { "new_floatp", _wrap_new_floatp, METH_NOARGS, "new_floatp() -> floatp"},
	 { "delete_floatp", _wrap_delete_floatp, METH_O, "delete_floatp(floatp self)"},
	 { "floatp_assign", _wrap_floatp_assign, METH_VARARGS, "floatp_assign(floatp self, float value)"},
	 { "floatp_value", _wrap_floatp_value, METH_O, "floatp_value(floatp self) -> float"},
	 { "floatp_cast", _wrap_floatp_cast, METH_O, "floatp_cast(floatp self) -> float *"},
	 { "floatp_frompointer", _wrap_floatp_frompointer, METH_O, "floatp_frompointer(float * t) -> floatp"},
	 { "floatp_swigregister", floatp_swigregister, METH_O, NULL},
	 { "floatp_swiginit", floatp_swiginit, METH_VARARGS, NULL},
	 { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"},
	 { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"},
	 { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "doublep_assign(doublep self, double value)"},
	 { "doublep_value", _wrap_doublep_value, METH_O, "doublep_value(doublep self) -> double"},
	 { "doublep_cast", _wrap_doublep_cast, METH_O, "doublep_cast(doublep self) -> double *"},
	 { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "doublep_frompointer(double * t) -> doublep"},
	 { "doublep_swigregister", doublep_swigregister, METH_O, NULL},
	 { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL},
	 { "new_SbDict", _wrap_new_SbDict, METH_VARARGS, "\n"
		"SbDict(int const entries=251)\n"
		"new_SbDict(SbDict srcFrom) -> SbDict\n"
		""},
	 { "delete_SbDict", _wrap_delete_SbDict, METH_O, "delete_SbDict(SbDict self)"},
	 { "SbDict_applyToAll", _wrap_SbDict_applyToAll, METH_VARARGS, "\n"
		"SbDict_applyToAll(SbDict self, SbDictApplyFunc * rtn)\n"
		"SbDict_applyToAll(SbDict self, SbDictApplyDataFunc * rtn, void * data)\n"
		""},
	 { "SbDict_clear", _wrap_SbDict_clear, METH_O, "SbDict_clear(SbDict self)"},
	 { "SbDict_enter", _wrap_SbDict_enter, METH_VARARGS, "SbDict_enter(SbDict self, SbDict::Key const key, void *const value) -> SbBool"},
	 { "SbDict_find", _wrap_SbDict_find, METH_VARARGS, "SbDict_find(SbDict self, SbDict::Key const key, void *& value) -> SbBool"},
	 { "SbDict_makePList", _wrap_SbDict_makePList, METH_VARARGS, "SbDict_makePList(SbDict self, SbPList keys, SbPList values)"},
	 { "SbDict_remove", _wrap_SbDict_remove, METH_VARARGS, "SbDict_remove(SbDict self, SbDict::Key const key) -> SbBool"},
	 { "SbDict_setHashingFunction", _wrap_SbDict_setHashingFunction, METH_VARARGS, "SbDict_setHashingFunction(SbDict self, SbDictHashingFunc * func)"},
	 { "SbDict_swigregister", SbDict_swigregister, METH_O, NULL},
	 { "SbDict_swiginit", SbDict_swiginit, METH_VARARGS, NULL},
	 { "SoType_fromName", _wrap_SoType_fromName, METH_O, "SoType_fromName(SbName name) -> SoType"},
	 { "SoType_getName", _wrap_SoType_getName, METH_O, "SoType_getName(SoType self) -> SbName"},
	 { "SoType_getParent", _wrap_SoType_getParent, METH_O, "SoType_getParent(SoType self) -> SoType"},
	 { "SoType_isDerivedFrom", _wrap_SoType_isDerivedFrom, METH_VARARGS, "SoType_isDerivedFrom(SoType self, SoType type) -> SbBool"},
	 { "SoType_getAllDerivedFrom", _wrap_SoType_getAllDerivedFrom, METH_VARARGS, "SoType_getAllDerivedFrom(SoType type, SoTypeList list) -> int"},
	 { "SoType_canCreateInstance", _wrap_SoType_canCreateInstance, METH_O, "SoType_canCreateInstance(SoType self) -> SbBool"},
	 { "SoType_getData", _wrap_SoType_getData, METH_O, "SoType_getData(SoType self) -> uint16_t"},
	 { "SoType_getKey", _wrap_SoType_getKey, METH_O, "SoType_getKey(SoType self) -> int16_t"},
	 { "SoType___eq__", _wrap_SoType___eq__, METH_VARARGS, "SoType___eq__(SoType self, SoType type) -> SbBool"},
	 { "SoType___ne__", _wrap_SoType___ne__, METH_VARARGS, "SoType___ne__(SoType self, SoType type) -> SbBool"},
	 { "SoType___lt__", _wrap_SoType___lt__, METH_VARARGS, "SoType___lt__(SoType self, SoType type) -> SbBool"},
	 { "SoType___le__", _wrap_SoType___le__, METH_VARARGS, "SoType___le__(SoType self, SoType type) -> SbBool"},
	 { "SoType___ge__", _wrap_SoType___ge__, METH_VARARGS, "SoType___ge__(SoType self, SoType type) -> SbBool"},
	 { "SoType___gt__", _wrap_SoType___gt__, METH_VARARGS, "SoType___gt__(SoType self, SoType type) -> SbBool"},
	 { "SoType_removeType", _wrap_SoType_removeType, METH_O, "SoType_removeType(SbName name) -> SbBool"},
	 { "SoType_init", _wrap_SoType_init, METH_NOARGS, "SoType_init()"},
	 { "SoType_fromKey", _wrap_SoType_fromKey, METH_O, "SoType_fromKey(uint16_t key) -> SoType"},
	 { "SoType_badType", _wrap_SoType_badType, METH_NOARGS, "SoType_badType() -> SoType"},
	 { "SoType_isBad", _wrap_SoType_isBad, METH_O, "SoType_isBad(SoType self) -> SbBool"},
	 { "SoType_makeInternal", _wrap_SoType_makeInternal, METH_O, "SoType_makeInternal(SoType self)"},
	 { "SoType_isInternal", _wrap_SoType_isInternal, METH_O, "SoType_isInternal(SoType self) -> SbBool"},
	 { "SoType_getNumTypes", _wrap_SoType_getNumTypes, METH_NOARGS, "SoType_getNumTypes() -> int"},
	 { "SoType_getInstantiationMethod", _wrap_SoType_getInstantiationMethod, METH_O, "SoType_getInstantiationMethod(SoType self) -> SoType::instantiationMethod"},
	 { "SoType_createInstance", _wrap_SoType_createInstance, METH_O, "SoType_createInstance(SoType self) -> PyObject *"},
	 { "new_SoType", _wrap_new_SoType, METH_NOARGS, "new_SoType() -> SoType"},
	 { "delete_SoType", _wrap_delete_SoType, METH_O, "delete_SoType(SoType self)"},
	 { "SoType_swigregister", SoType_swigregister, METH_O, NULL},
	 { "SoType_swiginit", SoType_swiginit, METH_VARARGS, NULL},
	 { "new_SbPList", _wrap_new_SbPList, METH_VARARGS, "\n"
		"SbPList(int const sizehint=)\n"
		"new_SbPList(SbPList l) -> SbPList\n"
		""},
	 { "delete_SbPList", _wrap_delete_SbPList, METH_O, "delete_SbPList(SbPList self)"},
	 { "SbPList_copy", _wrap_SbPList_copy, METH_VARARGS, "SbPList_copy(SbPList self, SbPList l)"},
	 { "SbPList_fit", _wrap_SbPList_fit, METH_O, "SbPList_fit(SbPList self)"},
	 { "SbPList_append", _wrap_SbPList_append, METH_VARARGS, "SbPList_append(SbPList self, void * item)"},
	 { "SbPList_find", _wrap_SbPList_find, METH_VARARGS, "SbPList_find(SbPList self, void const * item) -> int"},
	 { "SbPList_insert", _wrap_SbPList_insert, METH_VARARGS, "SbPList_insert(SbPList self, void * item, int const insertbefore)"},
	 { "SbPList_removeItem", _wrap_SbPList_removeItem, METH_VARARGS, "SbPList_removeItem(SbPList self, void * item)"},
	 { "SbPList_remove", _wrap_SbPList_remove, METH_VARARGS, "SbPList_remove(SbPList self, int const index)"},
	 { "SbPList_removeFast", _wrap_SbPList_removeFast, METH_VARARGS, "SbPList_removeFast(SbPList self, int const index)"},
	 { "SbPList_getLength", _wrap_SbPList_getLength, METH_O, "SbPList_getLength(SbPList self) -> int"},
	 { "SbPList_truncate", _wrap_SbPList_truncate, METH_VARARGS, "SbPList_truncate(SbPList self, int const length, int const fit=0)"},
	 { "SbPList_getArrayPtr", _wrap_SbPList_getArrayPtr, METH_VARARGS, "SbPList_getArrayPtr(SbPList self, int const start=0)"},
	 { "SbPList___eq__", _wrap_SbPList___eq__, METH_VARARGS, "SbPList___eq__(SbPList self, SbPList l) -> int"},
	 { "SbPList___ne__", _wrap_SbPList___ne__, METH_VARARGS, "SbPList___ne__(SbPList self, SbPList l) -> int"},
	 { "SbPList_get", _wrap_SbPList_get, METH_VARARGS, "SbPList_get(SbPList self, int const index) -> void *"},
	 { "SbPList_set", _wrap_SbPList_set, METH_VARARGS, "SbPList_set(SbPList self, int const index, void * item)"},
	 { "SbPList___getitem__", _wrap_SbPList___getitem__, METH_VARARGS, "SbPList___getitem__(SbPList self, int i) -> void *"},
	 { "SbPList___setitem__", _wrap_SbPList___setitem__, METH_VARARGS, "SbPList___setitem__(SbPList self, int i, void * val)"},
	 { "SbPList_swigregister", SbPList_swigregister, METH_O, NULL},
	 { "SbPList_swiginit", SbPList_swiginit, METH_VARARGS, NULL},
	 { "new_SbIntList", _wrap_new_SbIntList, METH_VARARGS, "\n"
		"SbIntList()\n"
		"new_SbIntList(int const sizehint) -> SbIntList\n"
		""},
	 { "SbIntList_append", _wrap_SbIntList_append, METH_VARARGS, "SbIntList_append(SbIntList self, int const item)"},
	 { "SbIntList_find", _wrap_SbIntList_find, METH_VARARGS, "SbIntList_find(SbIntList self, int const item) -> int"},
	 { "SbIntList_insert", _wrap_SbIntList_insert, METH_VARARGS, "SbIntList_insert(SbIntList self, int const item, int const addbefore)"},
	 { "SbIntList___setitem__", _wrap_SbIntList___setitem__, METH_VARARGS, "SbIntList___setitem__(SbIntList self, int const i, int * value)"},
	 { "SbIntList___getitem__", _wrap_SbIntList___getitem__, METH_VARARGS, "SbIntList___getitem__(SbIntList self, int const i) -> int &"},
	 { "SbIntList_get", _wrap_SbIntList_get, METH_VARARGS, "SbIntList_get(SbIntList self, int const i) -> int"},
	 { "delete_SbIntList", _wrap_delete_SbIntList, METH_O, "delete_SbIntList(SbIntList self)"},
	 { "SbIntList_swigregister", SbIntList_swigregister, METH_O, NULL},
	 { "SbIntList_swiginit", SbIntList_swiginit, METH_VARARGS, NULL},
	 { "new_SbString", _wrap_new_SbString, METH_VARARGS, "\n"
		"SbString()\n"
		"SbString(char const * s)\n"
		"SbString(wchar_t const * s)\n"
		"SbString(char const * s, int start, int end)\n"
		"SbString(SbString s)\n"
		"new_SbString(int const digits) -> SbString\n"
		""},
	 { "delete_SbString", _wrap_delete_SbString, METH_O, "delete_SbString(SbString self)"},
	 { "SbString_hash", _wrap_SbString_hash, METH_VARARGS, "\n"
		"SbString_hash() -> uint32_t\n"
		"SbString_hash(char const * s) -> uint32_t\n"
		""},
	 { "SbString_getLength", _wrap_SbString_getLength, METH_O, "SbString_getLength(SbString self) -> int"},
	 { "SbString_makeEmpty", _wrap_SbString_makeEmpty, METH_VARARGS, "SbString_makeEmpty(SbString self, SbBool freeold=1)"},
	 { "SbString_getString", _wrap_SbString_getString, METH_O, "SbString_getString(SbString self) -> char const *"},
	 { "SbString_getSubString", _wrap_SbString_getSubString, METH_VARARGS, "SbString_getSubString(SbString self, int startidx, int endidx=-1) -> SbString"},
	 { "SbString_deleteSubString", _wrap_SbString_deleteSubString, METH_VARARGS, "SbString_deleteSubString(SbString self, int startidx, int endidx=-1)"},
	 { "SbString_addIntString", _wrap_SbString_addIntString, METH_VARARGS, "SbString_addIntString(SbString self, int const value)"},
	 { "SbString___iadd__", _wrap_SbString___iadd__, METH_VARARGS, "\n"
		"SbString___iadd__(SbString self, char const * s) -> SbString\n"
		"SbString___iadd__(SbString self, SbString s) -> SbString\n"
		"SbString___iadd__(SbString self, char const c) -> SbString\n"
		""},
	 { "SbString_compareSubString", _wrap_SbString_compareSubString, METH_VARARGS, "SbString_compareSubString(SbString self, char const * text, int offset=0) -> int"},
	 { "SbString_sprintf", _wrap_SbString_sprintf, METH_VARARGS, "SbString_sprintf(SbString self, char const * formatstr) -> SbString"},
	 { "SbString_apply", _wrap_SbString_apply, METH_VARARGS, "SbString_apply(SbString self, char (*)(char) func)"},
	 { "SbString_find", _wrap_SbString_find, METH_VARARGS, "SbString_find(SbString self, SbString s) -> int"},
	 { "SbString_findAll", _wrap_SbString_findAll, METH_VARARGS, "SbString_findAll(SbString self, SbString s, SbIntList found) -> SbBool"},
	 { "SbString_lower", _wrap_SbString_lower, METH_O, "SbString_lower(SbString self) -> SbString"},
	 { "SbString_upper", _wrap_SbString_upper, METH_O, "SbString_upper(SbString self) -> SbString"},
	 { "SbString__print", _wrap_SbString__print, METH_VARARGS, "SbString__print(SbString self, std::FILE * fp)"},
	 { "SbString___eq__", _wrap_SbString___eq__, METH_VARARGS, "\n"
		"SbString___eq__(SbString self, SbString u) -> int\n"
		"SbString___eq__(SbString self, char * u) -> int\n"
		""},
	 { "SbString___nq__", _wrap_SbString___nq__, METH_VARARGS, "\n"
		"SbString___nq__(SbString self, SbString u) -> int\n"
		"SbString___nq__(SbString self, char * u) -> int\n"
		""},
	 { "SbString___getitem__", _wrap_SbString___getitem__, METH_VARARGS, "SbString___getitem__(SbString self, int i) -> char"},
	 { "SbString___repr__", _wrap_SbString___repr__, METH_O, "SbString___repr__(SbString self) -> char const *"},
	 { "SbString_swigregister", SbString_swigregister, METH_O, NULL},
	 { "SbString_swiginit", SbString_swiginit, METH_VARARGS, NULL},
	 { "new_SbName", _wrap_new_SbName, METH_VARARGS, "\n"
		"SbName()\n"
		"SbName(char const * namestring)\n"
		"SbName(SbString str)\n"
		"new_SbName(SbName name) -> SbName\n"
		""},
	 { "delete_SbName", _wrap_delete_SbName, METH_O, "delete_SbName(SbName self)"},
	 { "SbName_getString", _wrap_SbName_getString, METH_O, "SbName_getString(SbName self) -> char const *"},
	 { "SbName_getLength", _wrap_SbName_getLength, METH_O, "SbName_getLength(SbName self) -> int"},
	 { "SbName_isIdentStartChar", _wrap_SbName_isIdentStartChar, METH_O, "SbName_isIdentStartChar(char const c) -> SbBool"},
	 { "SbName_isIdentChar", _wrap_SbName_isIdentChar, METH_O, "SbName_isIdentChar(char const c) -> SbBool"},
	 { "SbName_isBaseNameStartChar", _wrap_SbName_isBaseNameStartChar, METH_O, "SbName_isBaseNameStartChar(char const c) -> SbBool"},
	 { "SbName_isBaseNameChar", _wrap_SbName_isBaseNameChar, METH_O, "SbName_isBaseNameChar(char const c) -> SbBool"},
	 { "SbName_empty", _wrap_SbName_empty, METH_NOARGS, "SbName_empty() -> SbName"},
	 { "SbName___eq__", _wrap_SbName___eq__, METH_VARARGS, "\n"
		"SbName___eq__(SbName self, SbName u) -> int\n"
		"SbName___eq__(SbName self, char * u) -> int\n"
		"SbName___eq__(SbName self, SbString u) -> int\n"
		""},
	 { "SbName___nq__", _wrap_SbName___nq__, METH_VARARGS, "\n"
		"SbName___nq__(SbName self, SbName u) -> int\n"
		"SbName___nq__(SbName self, char * u) -> int\n"
		"SbName___nq__(SbName self, SbString u) -> int\n"
		""},
	 { "SbName___getitem__", _wrap_SbName___getitem__, METH_VARARGS, "SbName___getitem__(SbName self, int i) -> char"},
	 { "SbName___repr__", _wrap_SbName___repr__, METH_O, "SbName___repr__(SbName self) -> char const *"},
	 { "SbName_swigregister", SbName_swigregister, METH_O, NULL},
	 { "SbName_swiginit", SbName_swiginit, METH_VARARGS, NULL},
	 { "new_SoError", _wrap_new_SoError, METH_NOARGS, "new_SoError() -> SoError"},
	 { "delete_SoError", _wrap_delete_SoError, METH_O, "delete_SoError(SoError self)"},
	 { "SoError_setHandlerCallback", _wrap_SoError_setHandlerCallback, METH_VARARGS, "SoError_setHandlerCallback(SoErrorCB *const func, void *const data)"},
	 { "SoError_getHandlerCallback", _wrap_SoError_getHandlerCallback, METH_NOARGS, "SoError_getHandlerCallback() -> SoErrorCB *"},
	 { "SoError_getHandlerData", _wrap_SoError_getHandlerData, METH_NOARGS, "SoError_getHandlerData() -> void *"},
	 { "SoError_getDebugString", _wrap_SoError_getDebugString, METH_O, "SoError_getDebugString(SoError self) -> SbString"},
	 { "SoError_getClassTypeId", _wrap_SoError_getClassTypeId, METH_NOARGS, "SoError_getClassTypeId() -> SoType"},
	 { "SoError_getTypeId", _wrap_SoError_getTypeId, METH_O, "SoError_getTypeId(SoError self) -> SoType"},
	 { "SoError_isOfType", _wrap_SoError_isOfType, METH_VARARGS, "SoError_isOfType(SoError self, SoType type) -> SbBool"},
	 { "SoError_post", _wrap_SoError_post, METH_VARARGS, "SoError_post(char const *const format)"},
	 { "SoError_getString", _wrap_SoError_getString, METH_VARARGS, "\n"
		"SoError_getString(SoNode node) -> SbString\n"
		"SoError_getString(SoPath path) -> SbString\n"
		"SoError_getString(SoEngine engine) -> SbString\n"
		""},
	 { "SoError_initClass", _wrap_SoError_initClass, METH_NOARGS, "SoError_initClass()"},
	 { "SoError_initClasses", _wrap_SoError_initClasses, METH_NOARGS, "SoError_initClasses()"},
	 { "SoError_swigregister", SoError_swigregister, METH_O, NULL},
	 { "SoError_swiginit", SoError_swiginit, METH_VARARGS, NULL},
	 { "SoDebugError_setHandlerCallback", _wrap_SoDebugError_setHandlerCallback, METH_VARARGS, "SoDebugError_setHandlerCallback(SoErrorCB *const function, void *const data)"},
	 { "SoDebugError_getHandlerCallback", _wrap_SoDebugError_getHandlerCallback, METH_NOARGS, "SoDebugError_getHandlerCallback() -> SoErrorCB *"},
	 { "SoDebugError_getHandlerData", _wrap_SoDebugError_getHandlerData, METH_NOARGS, "SoDebugError_getHandlerData() -> void *"},
	 { "SoDebugError_getClassTypeId", _wrap_SoDebugError_getClassTypeId, METH_NOARGS, "SoDebugError_getClassTypeId() -> SoType"},
	 { "SoDebugError_getTypeId", _wrap_SoDebugError_getTypeId, METH_O, "SoDebugError_getTypeId(SoDebugError self) -> SoType"},
	 { "SoDebugError_getSeverity", _wrap_SoDebugError_getSeverity, METH_O, "SoDebugError_getSeverity(SoDebugError self) -> SoDebugError::Severity"},
	 { "SoDebugError_post", _wrap_SoDebugError_post, METH_VARARGS, "SoDebugError_post(char const *const source, char const *const format)"},
	 { "SoDebugError_postWarning", _wrap_SoDebugError_postWarning, METH_VARARGS, "SoDebugError_postWarning(char const *const source, char const *const format)"},
	 { "SoDebugError_postInfo", _wrap_SoDebugError_postInfo, METH_VARARGS, "SoDebugError_postInfo(char const *const source, char const *const format)"},
	 { "SoDebugError_initClass", _wrap_SoDebugError_initClass, METH_NOARGS, "SoDebugError_initClass()"},
	 { "new_SoDebugError", _wrap_new_SoDebugError, METH_NOARGS, "new_SoDebugError() -> SoDebugError"},
	 { "delete_SoDebugError", _wrap_delete_SoDebugError, METH_O, "delete_SoDebugError(SoDebugError self)"},
	 { "SoDebugError_swigregister", SoDebugError_swigregister, METH_O, NULL},
	 { "SoDebugError_swiginit", SoDebugError_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec2s", _wrap_new_SbVec2s, METH_VARARGS, "\n"
		"SbVec2s()\n"
		"SbVec2s(short const [2] v)\n"
		"SbVec2s(short x, short y)\n"
		"SbVec2s(SbVec2us const & v)\n"
		"SbVec2s(SbVec2b v)\n"
		"SbVec2s(SbVec2i32 v)\n"
		"SbVec2s(SbVec2f v)\n"
		"new_SbVec2s(SbVec2d v) -> SbVec2s\n"
		""},
	 { "SbVec2s_setValue", _wrap_SbVec2s_setValue, METH_VARARGS, "\n"
		"SbVec2s_setValue(SbVec2s self, short const [2] v) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, short x, short y) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, SbVec2us const & v) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, SbVec2b v) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, SbVec2i32 v) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, SbVec2f v) -> SbVec2s\n"
		"SbVec2s_setValue(SbVec2s self, SbVec2d v) -> SbVec2s\n"
		""},
	 { "SbVec2s_getValue", _wrap_SbVec2s_getValue, METH_O, "SbVec2s_getValue(SbVec2s self)"},
	 { "SbVec2s_dot", _wrap_SbVec2s_dot, METH_VARARGS, "SbVec2s_dot(SbVec2s self, SbVec2s v) -> int32_t"},
	 { "SbVec2s_negate", _wrap_SbVec2s_negate, METH_O, "SbVec2s_negate(SbVec2s self)"},
	 { "SbVec2s___imul__", _wrap_SbVec2s___imul__, METH_VARARGS, "\n"
		"SbVec2s___imul__(SbVec2s self, int d) -> SbVec2s\n"
		"SbVec2s___imul__(SbVec2s self, double d) -> SbVec2s\n"
		""},
	 { "SbVec2s___itruediv__", _wrap_SbVec2s___itruediv__, METH_VARARGS, "\n"
		"SbVec2s___itruediv__(SbVec2s self, int d) -> SbVec2s\n"
		"SbVec2s___itruediv__(SbVec2s self, double d) -> SbVec2s\n"
		""},
	 { "SbVec2s___iadd__", _wrap_SbVec2s___iadd__, METH_VARARGS, "SbVec2s___iadd__(SbVec2s self, SbVec2s v) -> SbVec2s"},
	 { "SbVec2s___isub__", _wrap_SbVec2s___isub__, METH_VARARGS, "SbVec2s___isub__(SbVec2s self, SbVec2s v) -> SbVec2s"},
	 { "SbVec2s___neg__", _wrap_SbVec2s___neg__, METH_O, "SbVec2s___neg__(SbVec2s self) -> SbVec2s"},
	 { "SbVec2s_toString", _wrap_SbVec2s_toString, METH_O, "SbVec2s_toString(SbVec2s self) -> SbString"},
	 { "SbVec2s_fromString", _wrap_SbVec2s_fromString, METH_VARARGS, "SbVec2s_fromString(SbVec2s self, SbString str) -> SbBool"},
	 { "SbVec2s_output", _wrap_SbVec2s_output, METH_VARARGS, "SbVec2s_output(SbVec2s self, FILE * fp)"},
	 { "SbVec2s___add__", _wrap_SbVec2s___add__, METH_VARARGS, "SbVec2s___add__(SbVec2s self, SbVec2s u) -> SbVec2s"},
	 { "SbVec2s___sub__", _wrap_SbVec2s___sub__, METH_VARARGS, "SbVec2s___sub__(SbVec2s self, SbVec2s u) -> SbVec2s"},
	 { "SbVec2s___mul__", _wrap_SbVec2s___mul__, METH_VARARGS, "SbVec2s___mul__(SbVec2s self, double const d) -> SbVec2s"},
	 { "SbVec2s___rmul__", _wrap_SbVec2s___rmul__, METH_VARARGS, "SbVec2s___rmul__(SbVec2s self, double const d) -> SbVec2s"},
	 { "SbVec2s___div__", _wrap_SbVec2s___div__, METH_VARARGS, "SbVec2s___div__(SbVec2s self, double const d) -> SbVec2s"},
	 { "SbVec2s___truediv__", _wrap_SbVec2s___truediv__, METH_VARARGS, "SbVec2s___truediv__(SbVec2s self, double const d) -> SbVec2s"},
	 { "SbVec2s___eq__", _wrap_SbVec2s___eq__, METH_VARARGS, "SbVec2s___eq__(SbVec2s self, SbVec2s u) -> int"},
	 { "SbVec2s___nq__", _wrap_SbVec2s___nq__, METH_VARARGS, "SbVec2s___nq__(SbVec2s self, SbVec2s u) -> int"},
	 { "SbVec2s___getitem__", _wrap_SbVec2s___getitem__, METH_VARARGS, "SbVec2s___getitem__(SbVec2s self, int i) -> short"},
	 { "SbVec2s___setitem__", _wrap_SbVec2s___setitem__, METH_VARARGS, "SbVec2s___setitem__(SbVec2s self, int i, short value)"},
	 { "delete_SbVec2s", _wrap_delete_SbVec2s, METH_O, "delete_SbVec2s(SbVec2s self)"},
	 { "SbVec2s_swigregister", SbVec2s_swigregister, METH_O, NULL},
	 { "SbVec2s_swiginit", SbVec2s_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec2f", _wrap_new_SbVec2f, METH_VARARGS, "\n"
		"SbVec2f()\n"
		"SbVec2f(float const [2] v)\n"
		"SbVec2f(float x, float y)\n"
		"SbVec2f(SbVec2d v)\n"
		"SbVec2f(SbVec2b v)\n"
		"SbVec2f(SbVec2s v)\n"
		"new_SbVec2f(SbVec2i32 v) -> SbVec2f\n"
		""},
	 { "SbVec2f_setValue", _wrap_SbVec2f_setValue, METH_VARARGS, "\n"
		"SbVec2f_setValue(SbVec2f self, float const [2] v) -> SbVec2f\n"
		"SbVec2f_setValue(SbVec2f self, float x, float y) -> SbVec2f\n"
		"SbVec2f_setValue(SbVec2f self, SbVec2d v) -> SbVec2f\n"
		"SbVec2f_setValue(SbVec2f self, SbVec2b v) -> SbVec2f\n"
		"SbVec2f_setValue(SbVec2f self, SbVec2s v) -> SbVec2f\n"
		"SbVec2f_setValue(SbVec2f self, SbVec2i32 v) -> SbVec2f\n"
		""},
	 { "SbVec2f_getValue", _wrap_SbVec2f_getValue, METH_O, "SbVec2f_getValue(SbVec2f self)"},
	 { "SbVec2f_dot", _wrap_SbVec2f_dot, METH_VARARGS, "SbVec2f_dot(SbVec2f self, SbVec2f v) -> float"},
	 { "SbVec2f_equals", _wrap_SbVec2f_equals, METH_VARARGS, "SbVec2f_equals(SbVec2f self, SbVec2f v, float tolerance) -> SbBool"},
	 { "SbVec2f_length", _wrap_SbVec2f_length, METH_O, "SbVec2f_length(SbVec2f self) -> float"},
	 { "SbVec2f_sqrLength", _wrap_SbVec2f_sqrLength, METH_O, "SbVec2f_sqrLength(SbVec2f self) -> float"},
	 { "SbVec2f_negate", _wrap_SbVec2f_negate, METH_O, "SbVec2f_negate(SbVec2f self)"},
	 { "SbVec2f_normalize", _wrap_SbVec2f_normalize, METH_O, "SbVec2f_normalize(SbVec2f self) -> float"},
	 { "SbVec2f___imul__", _wrap_SbVec2f___imul__, METH_VARARGS, "SbVec2f___imul__(SbVec2f self, float d) -> SbVec2f"},
	 { "SbVec2f___itruediv__", _wrap_SbVec2f___itruediv__, METH_VARARGS, "SbVec2f___itruediv__(SbVec2f self, float d) -> SbVec2f"},
	 { "SbVec2f___iadd__", _wrap_SbVec2f___iadd__, METH_VARARGS, "SbVec2f___iadd__(SbVec2f self, SbVec2f v) -> SbVec2f"},
	 { "SbVec2f___isub__", _wrap_SbVec2f___isub__, METH_VARARGS, "SbVec2f___isub__(SbVec2f self, SbVec2f v) -> SbVec2f"},
	 { "SbVec2f___neg__", _wrap_SbVec2f___neg__, METH_O, "SbVec2f___neg__(SbVec2f self) -> SbVec2f"},
	 { "SbVec2f_toString", _wrap_SbVec2f_toString, METH_O, "SbVec2f_toString(SbVec2f self) -> SbString"},
	 { "SbVec2f_fromString", _wrap_SbVec2f_fromString, METH_VARARGS, "SbVec2f_fromString(SbVec2f self, SbString str) -> SbBool"},
	 { "SbVec2f_output", _wrap_SbVec2f_output, METH_VARARGS, "SbVec2f_output(SbVec2f self, FILE * fp)"},
	 { "SbVec2f___add__", _wrap_SbVec2f___add__, METH_VARARGS, "SbVec2f___add__(SbVec2f self, SbVec2f u) -> SbVec2f"},
	 { "SbVec2f___sub__", _wrap_SbVec2f___sub__, METH_VARARGS, "SbVec2f___sub__(SbVec2f self, SbVec2f u) -> SbVec2f"},
	 { "SbVec2f___mul__", _wrap_SbVec2f___mul__, METH_VARARGS, "SbVec2f___mul__(SbVec2f self, float const d) -> SbVec2f"},
	 { "SbVec2f___rmul__", _wrap_SbVec2f___rmul__, METH_VARARGS, "SbVec2f___rmul__(SbVec2f self, float const d) -> SbVec2f"},
	 { "SbVec2f___div__", _wrap_SbVec2f___div__, METH_VARARGS, "SbVec2f___div__(SbVec2f self, float const d) -> SbVec2f"},
	 { "SbVec2f___truediv__", _wrap_SbVec2f___truediv__, METH_VARARGS, "SbVec2f___truediv__(SbVec2f self, float const d) -> SbVec2f"},
	 { "SbVec2f___eq__", _wrap_SbVec2f___eq__, METH_VARARGS, "SbVec2f___eq__(SbVec2f self, SbVec2f u) -> int"},
	 { "SbVec2f___nq__", _wrap_SbVec2f___nq__, METH_VARARGS, "SbVec2f___nq__(SbVec2f self, SbVec2f u) -> int"},
	 { "SbVec2f___getitem__", _wrap_SbVec2f___getitem__, METH_VARARGS, "SbVec2f___getitem__(SbVec2f self, int i) -> float"},
	 { "SbVec2f___setitem__", _wrap_SbVec2f___setitem__, METH_VARARGS, "SbVec2f___setitem__(SbVec2f self, int i, float value)"},
	 { "delete_SbVec2f", _wrap_delete_SbVec2f, METH_O, "delete_SbVec2f(SbVec2f self)"},
	 { "SbVec2f_swigregister", SbVec2f_swigregister, METH_O, NULL},
	 { "SbVec2f_swiginit", SbVec2f_swiginit, METH_VARARGS, NULL},
	 { "new_SbTime", _wrap_new_SbTime, METH_VARARGS, "\n"
		"SbTime()\n"
		"SbTime(double const sec)\n"
		"SbTime(int32_t const sec, long const usec)\n"
		"new_SbTime(timeval const *const tv) -> SbTime\n"
		""},
	 { "SbTime_getTimeOfDay", _wrap_SbTime_getTimeOfDay, METH_NOARGS, "SbTime_getTimeOfDay() -> SbTime"},
	 { "SbTime_setToTimeOfDay", _wrap_SbTime_setToTimeOfDay, METH_O, "SbTime_setToTimeOfDay(SbTime self)"},
	 { "SbTime_zero", _wrap_SbTime_zero, METH_NOARGS, "SbTime_zero() -> SbTime"},
	 { "SbTime_max", _wrap_SbTime_max, METH_NOARGS, "SbTime_max() -> SbTime"},
	 { "SbTime_maxTime", _wrap_SbTime_maxTime, METH_NOARGS, "SbTime_maxTime() -> SbTime"},
	 { "SbTime_sleep", _wrap_SbTime_sleep, METH_O, "SbTime_sleep(int msec)"},
	 { "SbTime_setValue", _wrap_SbTime_setValue, METH_VARARGS, "\n"
		"SbTime_setValue(SbTime self, double const sec)\n"
		"SbTime_setValue(SbTime self, int32_t const sec, long const usec)\n"
		"SbTime_setValue(SbTime self, timeval const *const tv)\n"
		""},
	 { "SbTime_setMsecValue", _wrap_SbTime_setMsecValue, METH_VARARGS, "SbTime_setMsecValue(SbTime self, unsigned long const msec)"},
	 { "SbTime_getValue", _wrap_SbTime_getValue, METH_VARARGS, "\n"
		"SbTime_getValue(SbTime self) -> double\n"
		"SbTime_getValue(SbTime self, time_t & sec, long & usec)\n"
		"SbTime_getValue(SbTime self, timeval * tv)\n"
		""},
	 { "SbTime_getMsecValue", _wrap_SbTime_getMsecValue, METH_O, "SbTime_getMsecValue(SbTime self) -> unsigned long"},
	 { "SbTime_format", _wrap_SbTime_format, METH_VARARGS, "SbTime_format(SbTime self, char const *const fmt=\"%S.%i\") -> SbString"},
	 { "SbTime_formatDate", _wrap_SbTime_formatDate, METH_VARARGS, "SbTime_formatDate(SbTime self, char const *const fmt=None) -> SbString"},
	 { "SbTime_parsedate", _wrap_SbTime_parsedate, METH_VARARGS, "SbTime_parsedate(SbTime self, char const *const date) -> SbBool"},
	 { "SbTime___iadd__", _wrap_SbTime___iadd__, METH_VARARGS, "SbTime___iadd__(SbTime self, SbTime tm) -> SbTime"},
	 { "SbTime___isub__", _wrap_SbTime___isub__, METH_VARARGS, "SbTime___isub__(SbTime self, SbTime tm) -> SbTime"},
	 { "SbTime___neg__", _wrap_SbTime___neg__, METH_O, "SbTime___neg__(SbTime self) -> SbTime"},
	 { "SbTime___imul__", _wrap_SbTime___imul__, METH_VARARGS, "SbTime___imul__(SbTime self, double const s) -> SbTime"},
	 { "SbTime___itruediv__", _wrap_SbTime___itruediv__, METH_VARARGS, "SbTime___itruediv__(SbTime self, double const s) -> SbTime"},
	 { "SbTime___truediv__", _wrap_SbTime___truediv__, METH_VARARGS, "SbTime___truediv__(SbTime self, SbTime tm) -> double"},
	 { "SbTime___mod__", _wrap_SbTime___mod__, METH_VARARGS, "SbTime___mod__(SbTime self, SbTime tm) -> SbTime"},
	 { "SbTime___eq__", _wrap_SbTime___eq__, METH_VARARGS, "SbTime___eq__(SbTime self, SbTime tm) -> int"},
	 { "SbTime___ne__", _wrap_SbTime___ne__, METH_VARARGS, "SbTime___ne__(SbTime self, SbTime tm) -> int"},
	 { "SbTime___lt__", _wrap_SbTime___lt__, METH_VARARGS, "SbTime___lt__(SbTime self, SbTime tm) -> SbBool"},
	 { "SbTime___gt__", _wrap_SbTime___gt__, METH_VARARGS, "SbTime___gt__(SbTime self, SbTime tm) -> SbBool"},
	 { "SbTime___le__", _wrap_SbTime___le__, METH_VARARGS, "SbTime___le__(SbTime self, SbTime tm) -> SbBool"},
	 { "SbTime___ge__", _wrap_SbTime___ge__, METH_VARARGS, "SbTime___ge__(SbTime self, SbTime tm) -> SbBool"},
	 { "SbTime_output", _wrap_SbTime_output, METH_VARARGS, "SbTime_output(SbTime self, FILE * fp)"},
	 { "SbTime___add__", _wrap_SbTime___add__, METH_VARARGS, "SbTime___add__(SbTime self, SbTime u) -> SbTime"},
	 { "SbTime___sub__", _wrap_SbTime___sub__, METH_VARARGS, "SbTime___sub__(SbTime self, SbTime u) -> SbTime"},
	 { "SbTime___mul__", _wrap_SbTime___mul__, METH_VARARGS, "SbTime___mul__(SbTime self, double const d) -> SbTime"},
	 { "SbTime___rmul__", _wrap_SbTime___rmul__, METH_VARARGS, "SbTime___rmul__(SbTime self, double const d) -> SbTime"},
	 { "SbTime___div__", _wrap_SbTime___div__, METH_VARARGS, "SbTime___div__(SbTime self, double const d) -> SbTime"},
	 { "delete_SbTime", _wrap_delete_SbTime, METH_O, "delete_SbTime(SbTime self)"},
	 { "SbTime_swigregister", SbTime_swigregister, METH_O, NULL},
	 { "SbTime_swiginit", SbTime_swiginit, METH_VARARGS, NULL},
	 { "SoEvent_getClassTypeId", _wrap_SoEvent_getClassTypeId, METH_NOARGS, "SoEvent_getClassTypeId() -> SoType"},
	 { "SoEvent_getTypeId", _wrap_SoEvent_getTypeId, METH_O, "SoEvent_getTypeId(SoEvent self) -> SoType"},
	 { "SoEvent_initClass", _wrap_SoEvent_initClass, METH_NOARGS, "SoEvent_initClass()"},
	 { "new_SoEvent", _wrap_new_SoEvent, METH_NOARGS, "new_SoEvent() -> SoEvent"},
	 { "delete_SoEvent", _wrap_delete_SoEvent, METH_O, "delete_SoEvent(SoEvent self)"},
	 { "SoEvent_isOfType", _wrap_SoEvent_isOfType, METH_VARARGS, "SoEvent_isOfType(SoEvent self, SoType type) -> SbBool"},
	 { "SoEvent_setTime", _wrap_SoEvent_setTime, METH_VARARGS, "SoEvent_setTime(SoEvent self, SbTime t)"},
	 { "SoEvent_getTime", _wrap_SoEvent_getTime, METH_O, "SoEvent_getTime(SoEvent self) -> SbTime"},
	 { "SoEvent_setPosition", _wrap_SoEvent_setPosition, METH_VARARGS, "SoEvent_setPosition(SoEvent self, SbVec2s p)"},
	 { "SoEvent_getPosition", _wrap_SoEvent_getPosition, METH_VARARGS, "\n"
		"SoEvent_getPosition(SoEvent self) -> SbVec2s\n"
		"SoEvent_getPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2s\n"
		""},
	 { "SoEvent_getNormalizedPosition", _wrap_SoEvent_getNormalizedPosition, METH_VARARGS, "SoEvent_getNormalizedPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2f"},
	 { "SoEvent_setShiftDown", _wrap_SoEvent_setShiftDown, METH_VARARGS, "SoEvent_setShiftDown(SoEvent self, SbBool isDown)"},
	 { "SoEvent_wasShiftDown", _wrap_SoEvent_wasShiftDown, METH_O, "SoEvent_wasShiftDown(SoEvent self) -> SbBool"},
	 { "SoEvent_setCtrlDown", _wrap_SoEvent_setCtrlDown, METH_VARARGS, "SoEvent_setCtrlDown(SoEvent self, SbBool isDown)"},
	 { "SoEvent_wasCtrlDown", _wrap_SoEvent_wasCtrlDown, METH_O, "SoEvent_wasCtrlDown(SoEvent self) -> SbBool"},
	 { "SoEvent_setAltDown", _wrap_SoEvent_setAltDown, METH_VARARGS, "SoEvent_setAltDown(SoEvent self, SbBool isDown)"},
	 { "SoEvent_wasAltDown", _wrap_SoEvent_wasAltDown, METH_O, "SoEvent_wasAltDown(SoEvent self) -> SbBool"},
	 { "SoEvent_swigregister", SoEvent_swigregister, METH_O, NULL},
	 { "SoEvent_swiginit", SoEvent_swiginit, METH_VARARGS, NULL},
	 { "new_SoNotRec", _wrap_new_SoNotRec, METH_O, "new_SoNotRec(SoBase notifbase) -> SoNotRec"},
	 { "SoNotRec_setType", _wrap_SoNotRec_setType, METH_VARARGS, "SoNotRec_setType(SoNotRec self, SoNotRec::Type const type)"},
	 { "SoNotRec_getBase", _wrap_SoNotRec_getBase, METH_O, "SoNotRec_getBase(SoNotRec self) -> SoBase"},
	 { "SoNotRec_getType", _wrap_SoNotRec_getType, METH_O, "SoNotRec_getType(SoNotRec self) -> SoNotRec::Type"},
	 { "SoNotRec_getPrevious", _wrap_SoNotRec_getPrevious, METH_O, "SoNotRec_getPrevious(SoNotRec self) -> SoNotRec"},
	 { "SoNotRec_setPrevious", _wrap_SoNotRec_setPrevious, METH_VARARGS, "SoNotRec_setPrevious(SoNotRec self, SoNotRec prev)"},
	 { "SoNotRec_output", _wrap_SoNotRec_output, METH_VARARGS, "SoNotRec_output(SoNotRec self, FILE *const file)"},
	 { "SoNotRec_getOperationType", _wrap_SoNotRec_getOperationType, METH_O, "SoNotRec_getOperationType(SoNotRec self) -> SoNotRec::OperationType"},
	 { "SoNotRec_getIndex", _wrap_SoNotRec_getIndex, METH_O, "SoNotRec_getIndex(SoNotRec self) -> int"},
	 { "SoNotRec_getFieldNumIndices", _wrap_SoNotRec_getFieldNumIndices, METH_O, "SoNotRec_getFieldNumIndices(SoNotRec self) -> int"},
	 { "SoNotRec_getGroupChild", _wrap_SoNotRec_getGroupChild, METH_O, "SoNotRec_getGroupChild(SoNotRec self) -> SoBase"},
	 { "SoNotRec_getGroupPrevChild", _wrap_SoNotRec_getGroupPrevChild, METH_O, "SoNotRec_getGroupPrevChild(SoNotRec self) -> SoBase"},
	 { "SoNotRec_setOperationType", _wrap_SoNotRec_setOperationType, METH_VARARGS, "SoNotRec_setOperationType(SoNotRec self, SoNotRec::OperationType const opType)"},
	 { "SoNotRec_setIndex", _wrap_SoNotRec_setIndex, METH_VARARGS, "SoNotRec_setIndex(SoNotRec self, int const idx)"},
	 { "SoNotRec_setFieldNumIndices", _wrap_SoNotRec_setFieldNumIndices, METH_VARARGS, "SoNotRec_setFieldNumIndices(SoNotRec self, int const fldnumind)"},
	 { "SoNotRec_setGroupChild", _wrap_SoNotRec_setGroupChild, METH_VARARGS, "SoNotRec_setGroupChild(SoNotRec self, SoBase gc)"},
	 { "SoNotRec_setGroupPrevChild", _wrap_SoNotRec_setGroupPrevChild, METH_VARARGS, "SoNotRec_setGroupPrevChild(SoNotRec self, SoBase pc)"},
	 { "delete_SoNotRec", _wrap_delete_SoNotRec, METH_O, "delete_SoNotRec(SoNotRec self)"},
	 { "SoNotRec_swigregister", SoNotRec_swigregister, METH_O, NULL},
	 { "SoNotRec_swiginit", SoNotRec_swiginit, METH_VARARGS, NULL},
	 { "new_SoNotList", _wrap_new_SoNotList, METH_VARARGS, "\n"
		"SoNotList()\n"
		"new_SoNotList(SoNotList nl) -> SoNotList\n"
		""},
	 { "SoNotList_append", _wrap_SoNotList_append, METH_VARARGS, "\n"
		"SoNotList_append(SoNotList self, SoNotRec rec)\n"
		"SoNotList_append(SoNotList self, SoNotRec rec, SoField field)\n"
		"SoNotList_append(SoNotList self, SoNotRec rec, SoEngineOutput engineout)\n"
		""},
	 { "SoNotList_setLastType", _wrap_SoNotList_setLastType, METH_VARARGS, "SoNotList_setLastType(SoNotList self, SoNotRec::Type const type)"},
	 { "SoNotList_getFirstRec", _wrap_SoNotList_getFirstRec, METH_O, "SoNotList_getFirstRec(SoNotList self) -> SoNotRec"},
	 { "SoNotList_getLastRec", _wrap_SoNotList_getLastRec, METH_O, "SoNotList_getLastRec(SoNotList self) -> SoNotRec"},
	 { "SoNotList_getFirstRecAtNode", _wrap_SoNotList_getFirstRecAtNode, METH_O, "SoNotList_getFirstRecAtNode(SoNotList self) -> SoNotRec"},
	 { "SoNotList_getLastField", _wrap_SoNotList_getLastField, METH_O, "SoNotList_getLastField(SoNotList self) -> SoField"},
	 { "SoNotList_getLastEngineOutput", _wrap_SoNotList_getLastEngineOutput, METH_O, "SoNotList_getLastEngineOutput(SoNotList self) -> SoEngineOutput"},
	 { "SoNotList_getTimeStamp", _wrap_SoNotList_getTimeStamp, METH_O, "SoNotList_getTimeStamp(SoNotList self) -> SbUniqueId"},
	 { "SoNotList_output", _wrap_SoNotList_output, METH_VARARGS, "SoNotList_output(SoNotList self, FILE *const file=stdout)"},
	 { "delete_SoNotList", _wrap_delete_SoNotList, METH_O, "delete_SoNotList(SoNotList self)"},
	 { "SoNotList_swigregister", SoNotList_swigregister, METH_O, NULL},
	 { "SoNotList_swiginit", SoNotList_swiginit, METH_VARARGS, NULL},
	 { "delete_SoField", _wrap_delete_SoField, METH_O, "delete_SoField(SoField self)"},
	 { "SoField_initClass", _wrap_SoField_initClass, METH_NOARGS, "SoField_initClass()"},
	 { "SoField_initClasses", _wrap_SoField_initClasses, METH_NOARGS, "SoField_initClasses()"},
	 { "SoField_cleanupClass", _wrap_SoField_cleanupClass, METH_NOARGS, "SoField_cleanupClass()"},
	 { "SoField_setIgnored", _wrap_SoField_setIgnored, METH_VARARGS, "SoField_setIgnored(SoField self, SbBool ignore)"},
	 { "SoField_isIgnored", _wrap_SoField_isIgnored, METH_O, "SoField_isIgnored(SoField self) -> SbBool"},
	 { "SoField_setDefault", _wrap_SoField_setDefault, METH_VARARGS, "SoField_setDefault(SoField self, SbBool defaultVal)"},
	 { "SoField_isDefault", _wrap_SoField_isDefault, METH_O, "SoField_isDefault(SoField self) -> SbBool"},
	 { "SoField_getTypeId", _wrap_SoField_getTypeId, METH_O, "SoField_getTypeId(SoField self) -> SoType"},
	 { "SoField_getClassTypeId", _wrap_SoField_getClassTypeId, METH_NOARGS, "SoField_getClassTypeId() -> SoType"},
	 { "SoField_isOfType", _wrap_SoField_isOfType, METH_VARARGS, "SoField_isOfType(SoField self, SoType type) -> SbBool"},
	 { "SoField_enableConnection", _wrap_SoField_enableConnection, METH_VARARGS, "SoField_enableConnection(SoField self, SbBool flag)"},
	 { "SoField_isConnectionEnabled", _wrap_SoField_isConnectionEnabled, METH_O, "SoField_isConnectionEnabled(SoField self) -> SbBool"},
	 { "SoField_isConnectedFromEngine", _wrap_SoField_isConnectedFromEngine, METH_O, "SoField_isConnectedFromEngine(SoField self) -> SbBool"},
	 { "SoField_getConnectedEngine", _wrap_SoField_getConnectedEngine, METH_VARARGS, "SoField_getConnectedEngine(SoField self, SoEngineOutput *& master) -> SbBool"},
	 { "SoField_connectFrom", _wrap_SoField_connectFrom, METH_VARARGS, "\n"
		"SoField_connectFrom(SoField self, SoEngineOutput master, SbBool notnotify=0, SbBool append=0) -> SbBool\n"
		"SoField_connectFrom(SoField self, SoField master, SbBool notnotify=0, SbBool append=0) -> SbBool\n"
		""},
	 { "SoField_appendConnection", _wrap_SoField_appendConnection, METH_VARARGS, "\n"
		"SoField_appendConnection(SoField self, SoEngineOutput master, SbBool notnotify=0) -> SbBool\n"
		"SoField_appendConnection(SoField self, SoField master, SbBool notnotify=0) -> SbBool\n"
		""},
	 { "SoField_isConnectedFromField", _wrap_SoField_isConnectedFromField, METH_O, "SoField_isConnectedFromField(SoField self) -> SbBool"},
	 { "SoField_getConnectedField", _wrap_SoField_getConnectedField, METH_VARARGS, "SoField_getConnectedField(SoField self, SoField *& master) -> SbBool"},
	 { "SoField_getNumConnections", _wrap_SoField_getNumConnections, METH_O, "SoField_getNumConnections(SoField self) -> int"},
	 { "SoField_getForwardConnections", _wrap_SoField_getForwardConnections, METH_VARARGS, "SoField_getForwardConnections(SoField self, SoFieldList slavelist) -> int"},
	 { "SoField_getConnections", _wrap_SoField_getConnections, METH_VARARGS, "SoField_getConnections(SoField self, SoFieldList masterlist) -> int"},
	 { "SoField_disconnect", _wrap_SoField_disconnect, METH_VARARGS, "\n"
		"SoField_disconnect(SoField self, SoEngineOutput engineoutput)\n"
		"SoField_disconnect(SoField self, SoField field)\n"
		"SoField_disconnect(SoField self)\n"
		""},
	 { "SoField_isConnected", _wrap_SoField_isConnected, METH_O, "SoField_isConnected(SoField self) -> SbBool"},
	 { "SoField_setContainer", _wrap_SoField_setContainer, METH_VARARGS, "SoField_setContainer(SoField self, SoFieldContainer cont)"},
	 { "SoField_getContainer", _wrap_SoField_getContainer, METH_O, "SoField_getContainer(SoField self) -> SoFieldContainer"},
	 { "SoField_set", _wrap_SoField_set, METH_VARARGS, "SoField_set(SoField self, char const * valuestring) -> SbBool"},
	 { "SoField_shouldWrite", _wrap_SoField_shouldWrite, METH_O, "SoField_shouldWrite(SoField self) -> SbBool"},
	 { "SoField_touch", _wrap_SoField_touch, METH_O, "SoField_touch(SoField self)"},
	 { "SoField_startNotify", _wrap_SoField_startNotify, METH_O, "SoField_startNotify(SoField self)"},
	 { "SoField_notify", _wrap_SoField_notify, METH_VARARGS, "SoField_notify(SoField self, SoNotList nlist)"},
	 { "SoField_enableNotify", _wrap_SoField_enableNotify, METH_VARARGS, "SoField_enableNotify(SoField self, SbBool on) -> SbBool"},
	 { "SoField_isNotifyEnabled", _wrap_SoField_isNotifyEnabled, METH_O, "SoField_isNotifyEnabled(SoField self) -> SbBool"},
	 { "SoField_addAuditor", _wrap_SoField_addAuditor, METH_VARARGS, "SoField_addAuditor(SoField self, void * f, SoNotRec::Type type)"},
	 { "SoField_removeAuditor", _wrap_SoField_removeAuditor, METH_VARARGS, "SoField_removeAuditor(SoField self, void * f, SoNotRec::Type type)"},
	 { "SoField___eq__", _wrap_SoField___eq__, METH_VARARGS, "SoField___eq__(SoField self, SoField f) -> int"},
	 { "SoField___ne__", _wrap_SoField___ne__, METH_VARARGS, "SoField___ne__(SoField self, SoField f) -> int"},
	 { "SoField_connectionStatusChanged", _wrap_SoField_connectionStatusChanged, METH_VARARGS, "SoField_connectionStatusChanged(SoField self, int numconnections)"},
	 { "SoField_isReadOnly", _wrap_SoField_isReadOnly, METH_O, "SoField_isReadOnly(SoField self) -> SbBool"},
	 { "SoField_isSame", _wrap_SoField_isSame, METH_VARARGS, "SoField_isSame(SoField self, SoField f) -> SbBool"},
	 { "SoField_copyFrom", _wrap_SoField_copyFrom, METH_VARARGS, "SoField_copyFrom(SoField self, SoField f)"},
	 { "SoField_fixCopy", _wrap_SoField_fixCopy, METH_VARARGS, "SoField_fixCopy(SoField self, SbBool copyconnections)"},
	 { "SoField_referencesCopy", _wrap_SoField_referencesCopy, METH_O, "SoField_referencesCopy(SoField self) -> SbBool"},
	 { "SoField_copyConnection", _wrap_SoField_copyConnection, METH_VARARGS, "SoField_copyConnection(SoField self, SoField fromfield)"},
	 { "SoField_read", _wrap_SoField_read, METH_VARARGS, "SoField_read(SoField self, SoInput input, SbName name) -> SbBool"},
	 { "SoField_write", _wrap_SoField_write, METH_VARARGS, "SoField_write(SoField self, SoOutput out, SbName name)"},
	 { "SoField_countWriteRefs", _wrap_SoField_countWriteRefs, METH_VARARGS, "SoField_countWriteRefs(SoField self, SoOutput out)"},
	 { "SoField_setFieldType", _wrap_SoField_setFieldType, METH_VARARGS, "SoField_setFieldType(SoField self, int type)"},
	 { "SoField_getFieldType", _wrap_SoField_getFieldType, METH_O, "SoField_getFieldType(SoField self) -> int"},
	 { "SoField_getDirty", _wrap_SoField_getDirty, METH_O, "SoField_getDirty(SoField self) -> SbBool"},
	 { "SoField_setDirty", _wrap_SoField_setDirty, METH_VARARGS, "SoField_setDirty(SoField self, SbBool dirty)"},
	 { "SoField_evaluate", _wrap_SoField_evaluate, METH_O, "SoField_evaluate(SoField self)"},
	 { "SoField_get", _wrap_SoField_get, METH_O, "SoField_get(SoField self) -> SbString"},
	 { "SoField_swigregister", SoField_swigregister, METH_O, NULL},
	 { "delete_SoSField", _wrap_delete_SoSField, METH_O, "delete_SoSField(SoSField self)"},
	 { "SoSField_initClass", _wrap_SoSField_initClass, METH_NOARGS, "SoSField_initClass()"},
	 { "SoSField_getClassTypeId", _wrap_SoSField_getClassTypeId, METH_NOARGS, "SoSField_getClassTypeId() -> SoType"},
	 { "SoSField_atexit_cleanup", _wrap_SoSField_atexit_cleanup, METH_NOARGS, "SoSField_atexit_cleanup()"},
	 { "SoSField_swigregister", SoSField_swigregister, METH_O, NULL},
	 { "delete_SoMField", _wrap_delete_SoMField, METH_O, "delete_SoMField(SoMField self)"},
	 { "SoMField_getClassTypeId", _wrap_SoMField_getClassTypeId, METH_NOARGS, "SoMField_getClassTypeId() -> SoType"},
	 { "SoMField_atexit_cleanup", _wrap_SoMField_atexit_cleanup, METH_NOARGS, "SoMField_atexit_cleanup()"},
	 { "SoMField_getNum", _wrap_SoMField_getNum, METH_O, "SoMField_getNum(SoMField self) -> int"},
	 { "SoMField_setNum", _wrap_SoMField_setNum, METH_VARARGS, "SoMField_setNum(SoMField self, int const num)"},
	 { "SoMField_deleteValues", _wrap_SoMField_deleteValues, METH_VARARGS, "SoMField_deleteValues(SoMField self, int start, int num=-1)"},
	 { "SoMField_insertSpace", _wrap_SoMField_insertSpace, METH_VARARGS, "SoMField_insertSpace(SoMField self, int start, int num)"},
	 { "SoMField_set1", _wrap_SoMField_set1, METH_VARARGS, "SoMField_set1(SoMField self, int const index, char const *const valuestring) -> SbBool"},
	 { "SoMField_initClass", _wrap_SoMField_initClass, METH_NOARGS, "SoMField_initClass()"},
	 { "SoMField_enableDeleteValues", _wrap_SoMField_enableDeleteValues, METH_O, "SoMField_enableDeleteValues(SoMField self)"},
	 { "SoMField_isDeleteValuesEnabled", _wrap_SoMField_isDeleteValuesEnabled, METH_O, "SoMField_isDeleteValuesEnabled(SoMField self) -> SbBool"},
	 { "SoMField___len__", _wrap_SoMField___len__, METH_O, "SoMField___len__(SoMField self) -> int"},
	 { "SoMField_get1", _wrap_SoMField_get1, METH_VARARGS, "SoMField_get1(SoMField self, int const index) -> SbString"},
	 { "SoMField_swigregister", SoMField_swigregister, METH_O, NULL},
	 { "new_SoAuditorList", _wrap_new_SoAuditorList, METH_NOARGS, "new_SoAuditorList() -> SoAuditorList"},
	 { "delete_SoAuditorList", _wrap_delete_SoAuditorList, METH_O, "delete_SoAuditorList(SoAuditorList self)"},
	 { "SoAuditorList_append", _wrap_SoAuditorList_append, METH_VARARGS, "SoAuditorList_append(SoAuditorList self, void *const auditor, SoNotRec::Type const type)"},
	 { "SoAuditorList_set", _wrap_SoAuditorList_set, METH_VARARGS, "SoAuditorList_set(SoAuditorList self, int const index, void *const auditor, SoNotRec::Type const type)"},
	 { "SoAuditorList_getObject", _wrap_SoAuditorList_getObject, METH_VARARGS, "SoAuditorList_getObject(SoAuditorList self, int const index) -> void *"},
	 { "SoAuditorList_getType", _wrap_SoAuditorList_getType, METH_VARARGS, "SoAuditorList_getType(SoAuditorList self, int const index) -> SoNotRec::Type"},
	 { "SoAuditorList_getLength", _wrap_SoAuditorList_getLength, METH_O, "SoAuditorList_getLength(SoAuditorList self) -> int"},
	 { "SoAuditorList_find", _wrap_SoAuditorList_find, METH_VARARGS, "SoAuditorList_find(SoAuditorList self, void *const auditor, SoNotRec::Type const type) -> int"},
	 { "SoAuditorList_remove", _wrap_SoAuditorList_remove, METH_VARARGS, "\n"
		"SoAuditorList_remove(SoAuditorList self, int const index)\n"
		"SoAuditorList_remove(SoAuditorList self, void *const auditor, SoNotRec::Type const type)\n"
		""},
	 { "SoAuditorList_notify", _wrap_SoAuditorList_notify, METH_VARARGS, "SoAuditorList_notify(SoAuditorList self, SoNotList l)"},
	 { "SoAuditorList_swigregister", SoAuditorList_swigregister, METH_O, NULL},
	 { "SoAuditorList_swiginit", SoAuditorList_swiginit, METH_VARARGS, NULL},
	 { "SoBase_initClass", _wrap_SoBase_initClass, METH_NOARGS, "SoBase_initClass()"},
	 { "SoBase_ref", _wrap_SoBase_ref, METH_O, "SoBase_ref(SoBase self)"},
	 { "SoBase_unref", _wrap_SoBase_unref, METH_O, "SoBase_unref(SoBase self)"},
	 { "SoBase_unrefNoDelete", _wrap_SoBase_unrefNoDelete, METH_O, "SoBase_unrefNoDelete(SoBase self)"},
	 { "SoBase_getRefCount", _wrap_SoBase_getRefCount, METH_O, "SoBase_getRefCount(SoBase self) -> int32_t"},
	 { "SoBase_touch", _wrap_SoBase_touch, METH_O, "SoBase_touch(SoBase self)"},
	 { "SoBase_getTypeId", _wrap_SoBase_getTypeId, METH_O, "SoBase_getTypeId(SoBase self) -> SoType"},
	 { "SoBase_isOfType", _wrap_SoBase_isOfType, METH_VARARGS, "SoBase_isOfType(SoBase self, SoType type) -> SbBool"},
	 { "SoBase_getClassTypeId", _wrap_SoBase_getClassTypeId, METH_NOARGS, "SoBase_getClassTypeId() -> SoType"},
	 { "SoBase_getName", _wrap_SoBase_getName, METH_O, "SoBase_getName(SoBase self) -> SbName"},
	 { "SoBase_setName", _wrap_SoBase_setName, METH_VARARGS, "SoBase_setName(SoBase self, SbName newname)"},
	 { "SoBase_addName", _wrap_SoBase_addName, METH_VARARGS, "SoBase_addName(SoBase base, char const *const name)"},
	 { "SoBase_removeName", _wrap_SoBase_removeName, METH_VARARGS, "SoBase_removeName(SoBase base, char const *const name)"},
	 { "SoBase_startNotify", _wrap_SoBase_startNotify, METH_O, "SoBase_startNotify(SoBase self)"},
	 { "SoBase_notify", _wrap_SoBase_notify, METH_VARARGS, "SoBase_notify(SoBase self, SoNotList l)"},
	 { "SoBase_addAuditor", _wrap_SoBase_addAuditor, METH_VARARGS, "SoBase_addAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"},
	 { "SoBase_removeAuditor", _wrap_SoBase_removeAuditor, METH_VARARGS, "SoBase_removeAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"},
	 { "SoBase_getAuditors", _wrap_SoBase_getAuditors, METH_O, "SoBase_getAuditors(SoBase self) -> SoAuditorList"},
	 { "SoBase_addWriteReference", _wrap_SoBase_addWriteReference, METH_VARARGS, "SoBase_addWriteReference(SoBase self, SoOutput out, SbBool isfromfield=0)"},
	 { "SoBase_shouldWrite", _wrap_SoBase_shouldWrite, METH_O, "SoBase_shouldWrite(SoBase self) -> SbBool"},
	 { "SoBase_incrementCurrentWriteCounter", _wrap_SoBase_incrementCurrentWriteCounter, METH_NOARGS, "SoBase_incrementCurrentWriteCounter()"},
	 { "SoBase_decrementCurrentWriteCounter", _wrap_SoBase_decrementCurrentWriteCounter, METH_NOARGS, "SoBase_decrementCurrentWriteCounter()"},
	 { "SoBase_getNamedBase", _wrap_SoBase_getNamedBase, METH_VARARGS, "SoBase_getNamedBase(SbName name, SoType type) -> SoBase"},
	 { "SoBase_getNamedBases", _wrap_SoBase_getNamedBases, METH_VARARGS, "SoBase_getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"},
	 { "SoBase_read", _wrap_SoBase_read, METH_VARARGS, "SoBase_read(SoInput input, SoBase *& base, SoType expectedtype) -> SbBool"},
	 { "SoBase_setInstancePrefix", _wrap_SoBase_setInstancePrefix, METH_O, "SoBase_setInstancePrefix(SbString c)"},
	 { "SoBase_setTraceRefs", _wrap_SoBase_setTraceRefs, METH_O, "SoBase_setTraceRefs(SbBool trace)"},
	 { "SoBase_getTraceRefs", _wrap_SoBase_getTraceRefs, METH_NOARGS, "SoBase_getTraceRefs() -> SbBool"},
	 { "SoBase_connectRoute", _wrap_SoBase_connectRoute, METH_VARARGS, "SoBase_connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, SbName tonodename, SbName tofieldname) -> SbBool"},
	 { "SoBase_assertAlive", _wrap_SoBase_assertAlive, METH_O, "SoBase_assertAlive(SoBase self)"},
	 { "SoBase_readRoute", _wrap_SoBase_readRoute, METH_O, "SoBase_readRoute(SoInput input) -> SbBool"},
	 { "delete_SoBase", _wrap_delete_SoBase, METH_O, "delete_SoBase(SoBase self)"},
	 { "SoBase___hash__", _wrap_SoBase___hash__, METH_O, "SoBase___hash__(SoBase self) -> size_t"},
	 { "SoBase_swigregister", SoBase_swigregister, METH_O, NULL},
	 { "new_SoBaseList", _wrap_new_SoBaseList, METH_VARARGS, "\n"
		"SoBaseList()\n"
		"SoBaseList(int const size)\n"
		"new_SoBaseList(SoBaseList l) -> SoBaseList\n"
		""},
	 { "delete_SoBaseList", _wrap_delete_SoBaseList, METH_O, "delete_SoBaseList(SoBaseList self)"},
	 { "SoBaseList_append", _wrap_SoBaseList_append, METH_VARARGS, "SoBaseList_append(SoBaseList self, SoBase ptr)"},
	 { "SoBaseList_insert", _wrap_SoBaseList_insert, METH_VARARGS, "SoBaseList_insert(SoBaseList self, SoBase ptr, int const addbefore)"},
	 { "SoBaseList_remove", _wrap_SoBaseList_remove, METH_VARARGS, "SoBaseList_remove(SoBaseList self, int const index)"},
	 { "SoBaseList_removeItem", _wrap_SoBaseList_removeItem, METH_VARARGS, "SoBaseList_removeItem(SoBaseList self, SoBase item)"},
	 { "SoBaseList_truncate", _wrap_SoBaseList_truncate, METH_VARARGS, "SoBaseList_truncate(SoBaseList self, int const length)"},
	 { "SoBaseList_copy", _wrap_SoBaseList_copy, METH_VARARGS, "SoBaseList_copy(SoBaseList self, SoBaseList l)"},
	 { "SoBaseList_set", _wrap_SoBaseList_set, METH_VARARGS, "SoBaseList_set(SoBaseList self, int const i, SoBase ptr)"},
	 { "SoBaseList_addReferences", _wrap_SoBaseList_addReferences, METH_VARARGS, "SoBaseList_addReferences(SoBaseList self, SbBool const flag)"},
	 { "SoBaseList_isReferencing", _wrap_SoBaseList_isReferencing, METH_O, "SoBaseList_isReferencing(SoBaseList self) -> SbBool"},
	 { "SoBaseList___setitem__", _wrap_SoBaseList___setitem__, METH_VARARGS, "SoBaseList___setitem__(SoBaseList self, int const i, SoBase value)"},
	 { "SoBaseList___getitem__", _wrap_SoBaseList___getitem__, METH_VARARGS, "SoBaseList___getitem__(SoBaseList self, int const i) -> SoBase"},
	 { "SoBaseList_get", _wrap_SoBaseList_get, METH_VARARGS, "SoBaseList_get(SoBaseList self, int const i) -> SoBase"},
	 { "SoBaseList_swigregister", SoBaseList_swigregister, METH_O, NULL},
	 { "SoBaseList_swiginit", SoBaseList_swiginit, METH_VARARGS, NULL},
	 { "new_SoNodeList", _wrap_new_SoNodeList, METH_VARARGS, "\n"
		"SoNodeList()\n"
		"SoNodeList(int const size)\n"
		"new_SoNodeList(SoNodeList nl) -> SoNodeList\n"
		""},
	 { "delete_SoNodeList", _wrap_delete_SoNodeList, METH_O, "delete_SoNodeList(SoNodeList self)"},
	 { "SoNodeList_append", _wrap_SoNodeList_append, METH_VARARGS, "SoNodeList_append(SoNodeList self, SoNode ptr)"},
	 { "SoNodeList___setitem__", _wrap_SoNodeList___setitem__, METH_VARARGS, "SoNodeList___setitem__(SoNodeList self, int const i, SoNode value)"},
	 { "SoNodeList___getitem__", _wrap_SoNodeList___getitem__, METH_VARARGS, "SoNodeList___getitem__(SoNodeList self, int const i) -> SoNode"},
	 { "SoNodeList_get", _wrap_SoNodeList_get, METH_VARARGS, "SoNodeList_get(SoNodeList self, int const i) -> SoNode"},
	 { "SoNodeList_swigregister", SoNodeList_swigregister, METH_O, NULL},
	 { "SoNodeList_swiginit", SoNodeList_swiginit, METH_VARARGS, NULL},
	 { "new_SoDetailList", _wrap_new_SoDetailList, METH_VARARGS, "\n"
		"SoDetailList()\n"
		"SoDetailList(int const sizehint)\n"
		"new_SoDetailList(SoDetailList l) -> SoDetailList\n"
		""},
	 { "delete_SoDetailList", _wrap_delete_SoDetailList, METH_O, "delete_SoDetailList(SoDetailList self)"},
	 { "SoDetailList_append", _wrap_SoDetailList_append, METH_VARARGS, "SoDetailList_append(SoDetailList self, SoDetail detail)"},
	 { "SoDetailList_insert", _wrap_SoDetailList_insert, METH_VARARGS, "SoDetailList_insert(SoDetailList self, SoDetail detail, int const insertbefore)"},
	 { "SoDetailList_truncate", _wrap_SoDetailList_truncate, METH_VARARGS, "SoDetailList_truncate(SoDetailList self, int const length, int const fit=0)"},
	 { "SoDetailList_copy", _wrap_SoDetailList_copy, METH_VARARGS, "SoDetailList_copy(SoDetailList self, SoDetailList l)"},
	 { "SoDetailList_set", _wrap_SoDetailList_set, METH_VARARGS, "SoDetailList_set(SoDetailList self, int const index, SoDetail item)"},
	 { "SoDetailList___setitem__", _wrap_SoDetailList___setitem__, METH_VARARGS, "SoDetailList___setitem__(SoDetailList self, int const i, SoDetail value)"},
	 { "SoDetailList___getitem__", _wrap_SoDetailList___getitem__, METH_VARARGS, "SoDetailList___getitem__(SoDetailList self, int const i) -> SoDetail"},
	 { "SoDetailList_get", _wrap_SoDetailList_get, METH_VARARGS, "SoDetailList_get(SoDetailList self, int const i) -> SoDetail"},
	 { "SoDetailList_swigregister", SoDetailList_swigregister, METH_O, NULL},
	 { "SoDetailList_swiginit", SoDetailList_swiginit, METH_VARARGS, NULL},
	 { "new_SoTypeList", _wrap_new_SoTypeList, METH_VARARGS, "\n"
		"SoTypeList()\n"
		"SoTypeList(int const sizehint)\n"
		"new_SoTypeList(SoTypeList l) -> SoTypeList\n"
		""},
	 { "SoTypeList_append", _wrap_SoTypeList_append, METH_VARARGS, "SoTypeList_append(SoTypeList self, SoType type)"},
	 { "SoTypeList_find", _wrap_SoTypeList_find, METH_VARARGS, "SoTypeList_find(SoTypeList self, SoType type) -> int"},
	 { "SoTypeList_insert", _wrap_SoTypeList_insert, METH_VARARGS, "SoTypeList_insert(SoTypeList self, SoType type, int const insertbefore)"},
	 { "SoTypeList_set", _wrap_SoTypeList_set, METH_VARARGS, "SoTypeList_set(SoTypeList self, int const index, SoType item)"},
	 { "SoTypeList___setitem__", _wrap_SoTypeList___setitem__, METH_VARARGS, "SoTypeList___setitem__(SoTypeList self, int const i, SoType value)"},
	 { "SoTypeList___getitem__", _wrap_SoTypeList___getitem__, METH_VARARGS, "SoTypeList___getitem__(SoTypeList self, int const i) -> SoType"},
	 { "SoTypeList_get", _wrap_SoTypeList_get, METH_VARARGS, "SoTypeList_get(SoTypeList self, int const i) -> SoType"},
	 { "delete_SoTypeList", _wrap_delete_SoTypeList, METH_O, "delete_SoTypeList(SoTypeList self)"},
	 { "SoTypeList_swigregister", SoTypeList_swigregister, METH_O, NULL},
	 { "SoTypeList_swiginit", SoTypeList_swiginit, METH_VARARGS, NULL},
	 { "new_SoEnabledElementsList", _wrap_new_SoEnabledElementsList, METH_O, "new_SoEnabledElementsList(SoEnabledElementsList parentlist) -> SoEnabledElementsList"},
	 { "delete_SoEnabledElementsList", _wrap_delete_SoEnabledElementsList, METH_O, "delete_SoEnabledElementsList(SoEnabledElementsList self)"},
	 { "SoEnabledElementsList_getElements", _wrap_SoEnabledElementsList_getElements, METH_O, "SoEnabledElementsList_getElements(SoEnabledElementsList self) -> SoTypeList"},
	 { "SoEnabledElementsList_enable", _wrap_SoEnabledElementsList_enable, METH_VARARGS, "SoEnabledElementsList_enable(SoEnabledElementsList self, SoType elementtype, int const stackindex)"},
	 { "SoEnabledElementsList_merge", _wrap_SoEnabledElementsList_merge, METH_VARARGS, "SoEnabledElementsList_merge(SoEnabledElementsList self, SoEnabledElementsList eel)"},
	 { "SoEnabledElementsList_getCounter", _wrap_SoEnabledElementsList_getCounter, METH_NOARGS, "SoEnabledElementsList_getCounter() -> int"},
	 { "SoEnabledElementsList_swigregister", SoEnabledElementsList_swigregister, METH_O, NULL},
	 { "SoEnabledElementsList_swiginit", SoEnabledElementsList_swiginit, METH_VARARGS, NULL},
	 { "new_SoEngineOutputList", _wrap_new_SoEngineOutputList, METH_VARARGS, "\n"
		"SoEngineOutputList()\n"
		"SoEngineOutputList(int const sizehint)\n"
		"new_SoEngineOutputList(SoEngineOutputList l) -> SoEngineOutputList\n"
		""},
	 { "SoEngineOutputList_append", _wrap_SoEngineOutputList_append, METH_VARARGS, "SoEngineOutputList_append(SoEngineOutputList self, SoEngineOutput output)"},
	 { "SoEngineOutputList_insert", _wrap_SoEngineOutputList_insert, METH_VARARGS, "SoEngineOutputList_insert(SoEngineOutputList self, SoEngineOutput output, int const insertbefore)"},
	 { "SoEngineOutputList_set", _wrap_SoEngineOutputList_set, METH_VARARGS, "SoEngineOutputList_set(SoEngineOutputList self, int const idx, SoEngineOutput item)"},
	 { "SoEngineOutputList___setitem__", _wrap_SoEngineOutputList___setitem__, METH_VARARGS, "SoEngineOutputList___setitem__(SoEngineOutputList self, int const i, SoEngineOutput value)"},
	 { "SoEngineOutputList___getitem__", _wrap_SoEngineOutputList___getitem__, METH_VARARGS, "SoEngineOutputList___getitem__(SoEngineOutputList self, int const i) -> SoEngineOutput"},
	 { "SoEngineOutputList_get", _wrap_SoEngineOutputList_get, METH_VARARGS, "SoEngineOutputList_get(SoEngineOutputList self, int const i) -> SoEngineOutput"},
	 { "delete_SoEngineOutputList", _wrap_delete_SoEngineOutputList, METH_O, "delete_SoEngineOutputList(SoEngineOutputList self)"},
	 { "SoEngineOutputList_swigregister", SoEngineOutputList_swigregister, METH_O, NULL},
	 { "SoEngineOutputList_swiginit", SoEngineOutputList_swiginit, METH_VARARGS, NULL},
	 { "new_SoEngineList", _wrap_new_SoEngineList, METH_VARARGS, "\n"
		"SoEngineList()\n"
		"SoEngineList(int const size)\n"
		"new_SoEngineList(SoEngineList el) -> SoEngineList\n"
		""},
	 { "delete_SoEngineList", _wrap_delete_SoEngineList, METH_O, "delete_SoEngineList(SoEngineList self)"},
	 { "SoEngineList_append", _wrap_SoEngineList_append, METH_VARARGS, "SoEngineList_append(SoEngineList self, SoEngine ptr)"},
	 { "SoEngineList___setitem__", _wrap_SoEngineList___setitem__, METH_VARARGS, "SoEngineList___setitem__(SoEngineList self, int const i, SoEngine value)"},
	 { "SoEngineList___getitem__", _wrap_SoEngineList___getitem__, METH_VARARGS, "SoEngineList___getitem__(SoEngineList self, int const i) -> SoEngine"},
	 { "SoEngineList_get", _wrap_SoEngineList_get, METH_VARARGS, "SoEngineList_get(SoEngineList self, int const i) -> SoEngine"},
	 { "SoEngineList_swigregister", SoEngineList_swigregister, METH_O, NULL},
	 { "SoEngineList_swiginit", SoEngineList_swiginit, METH_VARARGS, NULL},
	 { "new_SoFieldList", _wrap_new_SoFieldList, METH_VARARGS, "\n"
		"SoFieldList()\n"
		"SoFieldList(int const sizehint)\n"
		"new_SoFieldList(SoFieldList l) -> SoFieldList\n"
		""},
	 { "SoFieldList_append", _wrap_SoFieldList_append, METH_VARARGS, "SoFieldList_append(SoFieldList self, SoField field)"},
	 { "SoFieldList_insert", _wrap_SoFieldList_insert, METH_VARARGS, "SoFieldList_insert(SoFieldList self, SoField field, int const insertbefore)"},
	 { "SoFieldList_set", _wrap_SoFieldList_set, METH_VARARGS, "SoFieldList_set(SoFieldList self, int const idx, SoField field)"},
	 { "SoFieldList___setitem__", _wrap_SoFieldList___setitem__, METH_VARARGS, "SoFieldList___setitem__(SoFieldList self, int const i, SoField value)"},
	 { "SoFieldList___getitem__", _wrap_SoFieldList___getitem__, METH_VARARGS, "SoFieldList___getitem__(SoFieldList self, int const i) -> SoField"},
	 { "SoFieldList_get", _wrap_SoFieldList_get, METH_VARARGS, "\n"
		"SoFieldList_get(SoFieldList self, int const idx) -> SoField\n"
		"SoFieldList_get(SoFieldList self, int const i) -> SoField\n"
		""},
	 { "delete_SoFieldList", _wrap_delete_SoFieldList, METH_O, "delete_SoFieldList(SoFieldList self)"},
	 { "SoFieldList_swigregister", SoFieldList_swigregister, METH_O, NULL},
	 { "SoFieldList_swiginit", SoFieldList_swiginit, METH_VARARGS, NULL},
	 { "new_SoPathList", _wrap_new_SoPathList, METH_VARARGS, "\n"
		"SoPathList()\n"
		"SoPathList(int const size)\n"
		"new_SoPathList(SoPathList pl) -> SoPathList\n"
		""},
	 { "delete_SoPathList", _wrap_delete_SoPathList, METH_O, "delete_SoPathList(SoPathList self)"},
	 { "SoPathList_append", _wrap_SoPathList_append, METH_VARARGS, "SoPathList_append(SoPathList self, SoPath path)"},
	 { "SoPathList_findPath", _wrap_SoPathList_findPath, METH_VARARGS, "SoPathList_findPath(SoPathList self, SoPath path) -> int"},
	 { "SoPathList_sort", _wrap_SoPathList_sort, METH_O, "SoPathList_sort(SoPathList self)"},
	 { "SoPathList_uniquify", _wrap_SoPathList_uniquify, METH_O, "SoPathList_uniquify(SoPathList self)"},
	 { "SoPathList___setitem__", _wrap_SoPathList___setitem__, METH_VARARGS, "SoPathList___setitem__(SoPathList self, int const i, SoPath value)"},
	 { "SoPathList___getitem__", _wrap_SoPathList___getitem__, METH_VARARGS, "SoPathList___getitem__(SoPathList self, int i) -> SoPath"},
	 { "SoPathList_get", _wrap_SoPathList_get, METH_VARARGS, "SoPathList_get(SoPathList self, int const i) -> SoPath"},
	 { "SoPathList_swigregister", SoPathList_swigregister, METH_O, NULL},
	 { "SoPathList_swiginit", SoPathList_swiginit, METH_VARARGS, NULL},
	 { "new_SoPickedPointList", _wrap_new_SoPickedPointList, METH_VARARGS, "\n"
		"SoPickedPointList()\n"
		"SoPickedPointList(int const sizehint)\n"
		"new_SoPickedPointList(SoPickedPointList l) -> SoPickedPointList\n"
		""},
	 { "delete_SoPickedPointList", _wrap_delete_SoPickedPointList, METH_O, "delete_SoPickedPointList(SoPickedPointList self)"},
	 { "SoPickedPointList_append", _wrap_SoPickedPointList_append, METH_VARARGS, "SoPickedPointList_append(SoPickedPointList self, SoPickedPoint pp)"},
	 { "SoPickedPointList_insert", _wrap_SoPickedPointList_insert, METH_VARARGS, "SoPickedPointList_insert(SoPickedPointList self, SoPickedPoint pp, int const insertbefore)"},
	 { "SoPickedPointList_truncate", _wrap_SoPickedPointList_truncate, METH_VARARGS, "SoPickedPointList_truncate(SoPickedPointList self, int const start, int const fit=0)"},
	 { "SoPickedPointList_set", _wrap_SoPickedPointList_set, METH_VARARGS, "SoPickedPointList_set(SoPickedPointList self, int const idx, SoPickedPoint pp)"},
	 { "SoPickedPointList___setitem__", _wrap_SoPickedPointList___setitem__, METH_VARARGS, "SoPickedPointList___setitem__(SoPickedPointList self, int const i, SoPickedPoint value)"},
	 { "SoPickedPointList___getitem__", _wrap_SoPickedPointList___getitem__, METH_VARARGS, "SoPickedPointList___getitem__(SoPickedPointList self, int const i) -> SoPickedPoint"},
	 { "SoPickedPointList_get", _wrap_SoPickedPointList_get, METH_VARARGS, "SoPickedPointList_get(SoPickedPointList self, int const i) -> SoPickedPoint"},
	 { "SoPickedPointList_swigregister", SoPickedPointList_swigregister, METH_O, NULL},
	 { "SoPickedPointList_swiginit", SoPickedPointList_swiginit, METH_VARARGS, NULL},
	 { "SoPath_initClass", _wrap_SoPath_initClass, METH_NOARGS, "SoPath_initClass()"},
	 { "new_SoPath", _wrap_new_SoPath, METH_VARARGS, "\n"
		"SoPath(int const approxlength=4)\n"
		"SoPath(SoNode head)\n"
		"new_SoPath(SoPath rhs) -> SoPath\n"
		""},
	 { "SoPath_getClassTypeId", _wrap_SoPath_getClassTypeId, METH_NOARGS, "SoPath_getClassTypeId() -> SoType"},
	 { "SoPath_getTypeId", _wrap_SoPath_getTypeId, METH_O, "SoPath_getTypeId(SoPath self) -> SoType"},
	 { "SoPath_setHead", _wrap_SoPath_setHead, METH_VARARGS, "SoPath_setHead(SoPath self, SoNode head)"},
	 { "SoPath_getHead", _wrap_SoPath_getHead, METH_O, "SoPath_getHead(SoPath self) -> SoNode"},
	 { "SoPath_append", _wrap_SoPath_append, METH_VARARGS, "\n"
		"SoPath_append(SoPath self, int const childindex)\n"
		"SoPath_append(SoPath self, SoNode node)\n"
		"SoPath_append(SoPath self, SoPath frompath)\n"
		""},
	 { "SoPath_push", _wrap_SoPath_push, METH_VARARGS, "SoPath_push(SoPath self, int const childindex)"},
	 { "SoPath_pop", _wrap_SoPath_pop, METH_O, "SoPath_pop(SoPath self)"},
	 { "SoPath_getTail", _wrap_SoPath_getTail, METH_O, "SoPath_getTail(SoPath self) -> SoNode"},
	 { "SoPath_getNode", _wrap_SoPath_getNode, METH_VARARGS, "SoPath_getNode(SoPath self, int const index) -> SoNode"},
	 { "SoPath_getNodeFromTail", _wrap_SoPath_getNodeFromTail, METH_VARARGS, "SoPath_getNodeFromTail(SoPath self, int const index) -> SoNode"},
	 { "SoPath_getIndex", _wrap_SoPath_getIndex, METH_VARARGS, "SoPath_getIndex(SoPath self, int const index) -> int"},
	 { "SoPath_getIndexFromTail", _wrap_SoPath_getIndexFromTail, METH_VARARGS, "SoPath_getIndexFromTail(SoPath self, int const index) -> int"},
	 { "SoPath_getLength", _wrap_SoPath_getLength, METH_O, "SoPath_getLength(SoPath self) -> int"},
	 { "SoPath_truncate", _wrap_SoPath_truncate, METH_VARARGS, "SoPath_truncate(SoPath self, int const length)"},
	 { "SoPath_findFork", _wrap_SoPath_findFork, METH_VARARGS, "SoPath_findFork(SoPath self, SoPath path) -> int"},
	 { "SoPath_findNode", _wrap_SoPath_findNode, METH_VARARGS, "SoPath_findNode(SoPath self, SoNode node) -> int"},
	 { "SoPath_containsNode", _wrap_SoPath_containsNode, METH_VARARGS, "SoPath_containsNode(SoPath self, SoNode node) -> SbBool"},
	 { "SoPath_containsPath", _wrap_SoPath_containsPath, METH_VARARGS, "SoPath_containsPath(SoPath self, SoPath path) -> SbBool"},
	 { "SoPath_copy", _wrap_SoPath_copy, METH_VARARGS, "SoPath_copy(SoPath self, int const startfromnodeindex=0, int numnodes=0) -> SoPath"},
	 { "SoPath_getByName", _wrap_SoPath_getByName, METH_VARARGS, "\n"
		"SoPath_getByName(SbName name) -> SoPath\n"
		"SoPath_getByName(SbName name, SoPathList l) -> int\n"
		""},
	 { "SoPath_insertIndex", _wrap_SoPath_insertIndex, METH_VARARGS, "SoPath_insertIndex(SoPath self, SoNode parent, int const newindex)"},
	 { "SoPath_removeIndex", _wrap_SoPath_removeIndex, METH_VARARGS, "SoPath_removeIndex(SoPath self, SoNode parent, int const oldindex)"},
	 { "SoPath_replaceIndex", _wrap_SoPath_replaceIndex, METH_VARARGS, "SoPath_replaceIndex(SoPath self, SoNode parent, int const index, SoNode newchild)"},
	 { "SoPath_isRelevantNotification", _wrap_SoPath_isRelevantNotification, METH_VARARGS, "SoPath_isRelevantNotification(SoPath self, SoNotList l) -> SbBool"},
	 { "SoPath_write", _wrap_SoPath_write, METH_VARARGS, "SoPath_write(SoPath self, SoWriteAction action)"},
	 { "SoPath___eq__", _wrap_SoPath___eq__, METH_VARARGS, "SoPath___eq__(SoPath self, SoPath u) -> int"},
	 { "SoPath___nq__", _wrap_SoPath___nq__, METH_VARARGS, "SoPath___nq__(SoPath self, SoPath u) -> int"},
	 { "SoPath_swigregister", SoPath_swigregister, METH_O, NULL},
	 { "SoPath_swiginit", SoPath_swiginit, METH_VARARGS, NULL},
	 { "new_SoLightPath", _wrap_new_SoLightPath, METH_VARARGS, "\n"
		"SoLightPath(SoNode node, int const approxlength)\n"
		"new_SoLightPath(int const approxlength) -> SoLightPath\n"
		""},
	 { "delete_SoLightPath", _wrap_delete_SoLightPath, METH_O, "delete_SoLightPath(SoLightPath self)"},
	 { "SoLightPath_setHead", _wrap_SoLightPath_setHead, METH_VARARGS, "SoLightPath_setHead(SoLightPath self, SoNode node)"},
	 { "SoLightPath_append", _wrap_SoLightPath_append, METH_VARARGS, "SoLightPath_append(SoLightPath self, int const childindex)"},
	 { "SoLightPath_push", _wrap_SoLightPath_push, METH_VARARGS, "SoLightPath_push(SoLightPath self, int const childindex)"},
	 { "SoLightPath_pop", _wrap_SoLightPath_pop, METH_O, "SoLightPath_pop(SoLightPath self)"},
	 { "SoLightPath_setTail", _wrap_SoLightPath_setTail, METH_VARARGS, "SoLightPath_setTail(SoLightPath self, int const childindex)"},
	 { "SoLightPath_getTail", _wrap_SoLightPath_getTail, METH_O, "SoLightPath_getTail(SoLightPath self) -> SoNode"},
	 { "SoLightPath_getHead", _wrap_SoLightPath_getHead, METH_O, "SoLightPath_getHead(SoLightPath self) -> SoNode"},
	 { "SoLightPath_getNode", _wrap_SoLightPath_getNode, METH_VARARGS, "SoLightPath_getNode(SoLightPath self, int const index) -> SoNode"},
	 { "SoLightPath_getIndex", _wrap_SoLightPath_getIndex, METH_VARARGS, "SoLightPath_getIndex(SoLightPath self, int const index) -> int"},
	 { "SoLightPath_getFullLength", _wrap_SoLightPath_getFullLength, METH_O, "SoLightPath_getFullLength(SoLightPath self) -> int"},
	 { "SoLightPath_truncate", _wrap_SoLightPath_truncate, METH_VARARGS, "SoLightPath_truncate(SoLightPath self, int const startindex)"},
	 { "SoLightPath_makeTempPath", _wrap_SoLightPath_makeTempPath, METH_VARARGS, "SoLightPath_makeTempPath(SoLightPath self, SoTempPath path)"},
	 { "SoLightPath_swigregister", SoLightPath_swigregister, METH_O, NULL},
	 { "SoLightPath_swiginit", SoLightPath_swiginit, METH_VARARGS, NULL},
	 { "SoFullPath_pop", _wrap_SoFullPath_pop, METH_O, "SoFullPath_pop(SoFullPath self)"},
	 { "SoFullPath_getTail", _wrap_SoFullPath_getTail, METH_O, "SoFullPath_getTail(SoFullPath self) -> SoNode"},
	 { "SoFullPath_getNodeFromTail", _wrap_SoFullPath_getNodeFromTail, METH_VARARGS, "SoFullPath_getNodeFromTail(SoFullPath self, int const index) -> SoNode"},
	 { "SoFullPath_getIndexFromTail", _wrap_SoFullPath_getIndexFromTail, METH_VARARGS, "SoFullPath_getIndexFromTail(SoFullPath self, int const index) -> int"},
	 { "SoFullPath_getLength", _wrap_SoFullPath_getLength, METH_O, "SoFullPath_getLength(SoFullPath self) -> int"},
	 { "SoFullPath_fromSoPath", _wrap_SoFullPath_fromSoPath, METH_O, "SoFullPath_fromSoPath(SoPath path) -> SoFullPath"},
	 { "SoFullPath_swigregister", SoFullPath_swigregister, METH_O, NULL},
	 { "SoTempPath_simpleAppend", _wrap_SoTempPath_simpleAppend, METH_VARARGS, "SoTempPath_simpleAppend(SoTempPath self, SoNode node, int const index)"},
	 { "SoTempPath_replaceTail", _wrap_SoTempPath_replaceTail, METH_VARARGS, "SoTempPath_replaceTail(SoTempPath self, SoNode node, int const index)"},
	 { "SoTempPath_swigregister", SoTempPath_swigregister, METH_O, NULL},
	 { "new_SoActionMethodList", _wrap_new_SoActionMethodList, METH_O, "new_SoActionMethodList(SoActionMethodList parentlist) -> SoActionMethodList"},
	 { "delete_SoActionMethodList", _wrap_delete_SoActionMethodList, METH_O, "delete_SoActionMethodList(SoActionMethodList self)"},
	 { "SoActionMethodList_addMethod", _wrap_SoActionMethodList_addMethod, METH_VARARGS, "SoActionMethodList_addMethod(SoActionMethodList self, SoType node, SoActionMethod const method)"},
	 { "SoActionMethodList_setUp", _wrap_SoActionMethodList_setUp, METH_O, "SoActionMethodList_setUp(SoActionMethodList self)"},
	 { "SoActionMethodList___setitem__", _wrap_SoActionMethodList___setitem__, METH_VARARGS, "SoActionMethodList___setitem__(SoActionMethodList self, int const i, SoActionMethod * value)"},
	 { "SoActionMethodList___getitem__", _wrap_SoActionMethodList___getitem__, METH_VARARGS, "SoActionMethodList___getitem__(SoActionMethodList self, int const i) -> SoActionMethod &"},
	 { "SoActionMethodList_get", _wrap_SoActionMethodList_get, METH_VARARGS, "SoActionMethodList_get(SoActionMethodList self, int const i) -> SoActionMethod"},
	 { "SoActionMethodList_swigregister", SoActionMethodList_swigregister, METH_O, NULL},
	 { "SoActionMethodList_swiginit", SoActionMethodList_swiginit, METH_VARARGS, NULL},
	 { "SoAction_initClass", _wrap_SoAction_initClass, METH_NOARGS, "SoAction_initClass()"},
	 { "SoAction_initClasses", _wrap_SoAction_initClasses, METH_NOARGS, "SoAction_initClasses()"},
	 { "delete_SoAction", _wrap_delete_SoAction, METH_O, "delete_SoAction(SoAction self)"},
	 { "SoAction_getClassTypeId", _wrap_SoAction_getClassTypeId, METH_NOARGS, "SoAction_getClassTypeId() -> SoType"},
	 { "SoAction_getTypeId", _wrap_SoAction_getTypeId, METH_O, "SoAction_getTypeId(SoAction self) -> SoType"},
	 { "SoAction_isOfType", _wrap_SoAction_isOfType, METH_VARARGS, "SoAction_isOfType(SoAction self, SoType type) -> SbBool"},
	 { "SoAction_apply", _wrap_SoAction_apply, METH_VARARGS, "\n"
		"SoAction_apply(SoAction self, SoNode root)\n"
		"SoAction_apply(SoAction self, SoPath path)\n"
		"SoAction_apply(SoAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		"SoAction_apply(SoAction self, SoAction beingApplied)\n"
		""},
	 { "SoAction_invalidateState", _wrap_SoAction_invalidateState, METH_O, "SoAction_invalidateState(SoAction self)"},
	 { "SoAction_nullAction", _wrap_SoAction_nullAction, METH_VARARGS, "SoAction_nullAction(SoAction action, SoNode node)"},
	 { "SoAction_getWhatAppliedTo", _wrap_SoAction_getWhatAppliedTo, METH_O, "SoAction_getWhatAppliedTo(SoAction self) -> SoAction::AppliedCode"},
	 { "SoAction_getNodeAppliedTo", _wrap_SoAction_getNodeAppliedTo, METH_O, "SoAction_getNodeAppliedTo(SoAction self) -> SoNode"},
	 { "SoAction_getPathAppliedTo", _wrap_SoAction_getPathAppliedTo, METH_O, "SoAction_getPathAppliedTo(SoAction self) -> SoPath"},
	 { "SoAction_getPathListAppliedTo", _wrap_SoAction_getPathListAppliedTo, METH_O, "SoAction_getPathListAppliedTo(SoAction self) -> SoPathList"},
	 { "SoAction_getOriginalPathListAppliedTo", _wrap_SoAction_getOriginalPathListAppliedTo, METH_O, "SoAction_getOriginalPathListAppliedTo(SoAction self) -> SoPathList"},
	 { "SoAction_isLastPathListAppliedTo", _wrap_SoAction_isLastPathListAppliedTo, METH_O, "SoAction_isLastPathListAppliedTo(SoAction self) -> SbBool"},
	 { "SoAction_getPathCode", _wrap_SoAction_getPathCode, METH_VARARGS, "SoAction_getPathCode(SoAction self, int & numindices, int const *& indices) -> SoAction::PathCode"},
	 { "SoAction_traverse", _wrap_SoAction_traverse, METH_VARARGS, "SoAction_traverse(SoAction self, SoNode node)"},
	 { "SoAction_hasTerminated", _wrap_SoAction_hasTerminated, METH_O, "SoAction_hasTerminated(SoAction self) -> SbBool"},
	 { "SoAction_getCurPath", _wrap_SoAction_getCurPath, METH_O, "SoAction_getCurPath(SoAction self) -> SoPath"},
	 { "SoAction_getState", _wrap_SoAction_getState, METH_O, "SoAction_getState(SoAction self) -> SoState"},
	 { "SoAction_getCurPathCode", _wrap_SoAction_getCurPathCode, METH_O, "SoAction_getCurPathCode(SoAction self) -> SoAction::PathCode"},
	 { "SoAction_getCurPathTail", _wrap_SoAction_getCurPathTail, METH_O, "SoAction_getCurPathTail(SoAction self) -> SoNode"},
	 { "SoAction_usePathCode", _wrap_SoAction_usePathCode, METH_VARARGS, "SoAction_usePathCode(SoAction self, int & numindices, int const *& indices)"},
	 { "SoAction_pushCurPath", _wrap_SoAction_pushCurPath, METH_VARARGS, "\n"
		"SoAction_pushCurPath(SoAction self, int const childindex, SoNode node=None)\n"
		"SoAction_pushCurPath(SoAction self)\n"
		""},
	 { "SoAction_popPushCurPath", _wrap_SoAction_popPushCurPath, METH_VARARGS, "SoAction_popPushCurPath(SoAction self, int const childindex, SoNode node=None)"},
	 { "SoAction_popCurPath", _wrap_SoAction_popCurPath, METH_VARARGS, "\n"
		"SoAction_popCurPath(SoAction self, SoAction::PathCode const prevpathcode)\n"
		"SoAction_popCurPath(SoAction self)\n"
		""},
	 { "SoAction_switchToPathTraversal", _wrap_SoAction_switchToPathTraversal, METH_VARARGS, "SoAction_switchToPathTraversal(SoAction self, SoPath path)"},
	 { "SoAction_switchToNodeTraversal", _wrap_SoAction_switchToNodeTraversal, METH_VARARGS, "SoAction_switchToNodeTraversal(SoAction self, SoNode node)"},
	 { "SoAction_swigregister", SoAction_swigregister, METH_O, NULL},
	 { "new_SoState", _wrap_new_SoState, METH_VARARGS, "new_SoState(SoAction action, SoTypeList enabledelements) -> SoState"},
	 { "delete_SoState", _wrap_delete_SoState, METH_O, "delete_SoState(SoState self)"},
	 { "SoState_getAction", _wrap_SoState_getAction, METH_O, "SoState_getAction(SoState self) -> SoAction"},
	 { "SoState_getElement", _wrap_SoState_getElement, METH_VARARGS, "SoState_getElement(SoState self, int const stackindex) -> SoElement"},
	 { "SoState_getConstElement", _wrap_SoState_getConstElement, METH_VARARGS, "SoState_getConstElement(SoState self, int const stackindex) -> SoElement"},
	 { "SoState_push", _wrap_SoState_push, METH_O, "SoState_push(SoState self)"},
	 { "SoState_pop", _wrap_SoState_pop, METH_O, "SoState_pop(SoState self)"},
	 { "SoState_output", _wrap_SoState_output, METH_VARARGS, "SoState_output(SoState self, FILE *const file=stdout)"},
	 { "SoState_isElementEnabled", _wrap_SoState_isElementEnabled, METH_VARARGS, "SoState_isElementEnabled(SoState self, int const stackindex) -> SbBool"},
	 { "SoState_getDepth", _wrap_SoState_getDepth, METH_O, "SoState_getDepth(SoState self) -> int"},
	 { "SoState_setCacheOpen", _wrap_SoState_setCacheOpen, METH_VARARGS, "SoState_setCacheOpen(SoState self, SbBool const flag)"},
	 { "SoState_isCacheOpen", _wrap_SoState_isCacheOpen, METH_O, "SoState_isCacheOpen(SoState self) -> SbBool"},
	 { "SoState_getElementNoPush", _wrap_SoState_getElementNoPush, METH_VARARGS, "SoState_getElementNoPush(SoState self, int const stackindex) -> SoElement"},
	 { "SoState_swigregister", SoState_swigregister, METH_O, NULL},
	 { "SoState_swiginit", SoState_swiginit, METH_VARARGS, NULL},
	 { "SoElement_initClass", _wrap_SoElement_initClass, METH_NOARGS, "SoElement_initClass()"},
	 { "SoElement_getClassTypeId", _wrap_SoElement_getClassTypeId, METH_NOARGS, "SoElement_getClassTypeId() -> SoType"},
	 { "SoElement_getClassStackIndex", _wrap_SoElement_getClassStackIndex, METH_NOARGS, "SoElement_getClassStackIndex() -> int"},
	 { "SoElement_getTypeId", _wrap_SoElement_getTypeId, METH_O, "SoElement_getTypeId(SoElement self) -> SoType"},
	 { "SoElement_getStackIndex", _wrap_SoElement_getStackIndex, METH_O, "SoElement_getStackIndex(SoElement self) -> int"},
	 { "SoElement_init", _wrap_SoElement_init, METH_VARARGS, "SoElement_init(SoElement self, SoState state)"},
	 { "SoElement_push", _wrap_SoElement_push, METH_VARARGS, "SoElement_push(SoElement self, SoState state)"},
	 { "SoElement_pop", _wrap_SoElement_pop, METH_VARARGS, "SoElement_pop(SoElement self, SoState state, SoElement prevTopElement)"},
	 { "SoElement_matches", _wrap_SoElement_matches, METH_VARARGS, "SoElement_matches(SoElement self, SoElement element) -> SbBool"},
	 { "SoElement_copyMatchInfo", _wrap_SoElement_copyMatchInfo, METH_O, "SoElement_copyMatchInfo(SoElement self) -> SoElement"},
	 { "SoElement_initElements", _wrap_SoElement_initElements, METH_NOARGS, "SoElement_initElements()"},
	 { "SoElement_getNumStackIndices", _wrap_SoElement_getNumStackIndices, METH_NOARGS, "SoElement_getNumStackIndices() -> int"},
	 { "SoElement_getIdFromStackIndex", _wrap_SoElement_getIdFromStackIndex, METH_O, "SoElement_getIdFromStackIndex(int const stackIndex) -> SoType"},
	 { "SoElement_setDepth", _wrap_SoElement_setDepth, METH_VARARGS, "SoElement_setDepth(SoElement self, int const depth)"},
	 { "SoElement_getDepth", _wrap_SoElement_getDepth, METH_O, "SoElement_getDepth(SoElement self) -> int"},
	 { "SoElement_output", _wrap_SoElement_output, METH_VARARGS, "SoElement_output(SoElement self, FILE * file=stdout)"},
	 { "delete_SoElement", _wrap_delete_SoElement, METH_O, "delete_SoElement(SoElement self)"},
	 { "SoElement_swigregister", SoElement_swigregister, METH_O, NULL},
	 { "SoInt32Element_getClassTypeId", _wrap_SoInt32Element_getClassTypeId, METH_NOARGS, "SoInt32Element_getClassTypeId() -> SoType"},
	 { "SoInt32Element_getClassStackIndex", _wrap_SoInt32Element_getClassStackIndex, METH_NOARGS, "SoInt32Element_getClassStackIndex() -> int"},
	 { "SoInt32Element_initClass", _wrap_SoInt32Element_initClass, METH_NOARGS, "SoInt32Element_initClass()"},
	 { "SoInt32Element_init", _wrap_SoInt32Element_init, METH_VARARGS, "SoInt32Element_init(SoInt32Element self, SoState state)"},
	 { "SoInt32Element_matches", _wrap_SoInt32Element_matches, METH_VARARGS, "SoInt32Element_matches(SoInt32Element self, SoElement element) -> SbBool"},
	 { "SoInt32Element_copyMatchInfo", _wrap_SoInt32Element_copyMatchInfo, METH_O, "SoInt32Element_copyMatchInfo(SoInt32Element self) -> SoElement"},
	 { "SoInt32Element_output", _wrap_SoInt32Element_output, METH_VARARGS, "SoInt32Element_output(SoInt32Element self, FILE * file)"},
	 { "SoInt32Element_set", _wrap_SoInt32Element_set, METH_VARARGS, "\n"
		"SoInt32Element_set(int const index, SoState state, SoNode node, int32_t const value)\n"
		"SoInt32Element_set(int const index, SoState state, int32_t const value)\n"
		""},
	 { "SoInt32Element_get", _wrap_SoInt32Element_get, METH_VARARGS, "SoInt32Element_get(int const index, SoState state) -> int32_t"},
	 { "SoInt32Element_setElt", _wrap_SoInt32Element_setElt, METH_VARARGS, "SoInt32Element_setElt(SoInt32Element self, int32_t value)"},
	 { "SoInt32Element_swigregister", SoInt32Element_swigregister, METH_O, NULL},
	 { "SoDecimationTypeElement_getClassTypeId", _wrap_SoDecimationTypeElement_getClassTypeId, METH_NOARGS, "SoDecimationTypeElement_getClassTypeId() -> SoType"},
	 { "SoDecimationTypeElement_getClassStackIndex", _wrap_SoDecimationTypeElement_getClassStackIndex, METH_NOARGS, "SoDecimationTypeElement_getClassStackIndex() -> int"},
	 { "SoDecimationTypeElement_createInstance", _wrap_SoDecimationTypeElement_createInstance, METH_NOARGS, "SoDecimationTypeElement_createInstance() -> void *"},
	 { "SoDecimationTypeElement_initClass", _wrap_SoDecimationTypeElement_initClass, METH_NOARGS, "SoDecimationTypeElement_initClass()"},
	 { "SoDecimationTypeElement_init", _wrap_SoDecimationTypeElement_init, METH_VARARGS, "SoDecimationTypeElement_init(SoDecimationTypeElement self, SoState state)"},
	 { "SoDecimationTypeElement_set", _wrap_SoDecimationTypeElement_set, METH_VARARGS, "\n"
		"SoDecimationTypeElement_set(SoState state, SoDecimationTypeElement::Type const type)\n"
		"SoDecimationTypeElement_set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)\n"
		""},
	 { "SoDecimationTypeElement_get", _wrap_SoDecimationTypeElement_get, METH_O, "SoDecimationTypeElement_get(SoState state) -> SoDecimationTypeElement::Type"},
	 { "SoDecimationTypeElement_getDefault", _wrap_SoDecimationTypeElement_getDefault, METH_NOARGS, "SoDecimationTypeElement_getDefault() -> SoDecimationTypeElement::Type"},
	 { "SoDecimationTypeElement_swigregister", SoDecimationTypeElement_swigregister, METH_O, NULL},
	 { "new_SoFieldData", _wrap_new_SoFieldData, METH_VARARGS, "\n"
		"SoFieldData()\n"
		"SoFieldData(SoFieldData fd)\n"
		"SoFieldData(SoFieldData fd)\n"
		"new_SoFieldData(int numfields) -> SoFieldData\n"
		""},
	 { "delete_SoFieldData", _wrap_delete_SoFieldData, METH_O, "delete_SoFieldData(SoFieldData self)"},
	 { "SoFieldData_addField", _wrap_SoFieldData_addField, METH_VARARGS, "SoFieldData_addField(SoFieldData self, SoFieldContainer base, char const * name, SoField field)"},
	 { "SoFieldData_overlay", _wrap_SoFieldData_overlay, METH_VARARGS, "SoFieldData_overlay(SoFieldData self, SoFieldContainer destTo, SoFieldContainer srcFrom, SbBool copyconnections)"},
	 { "SoFieldData_getNumFields", _wrap_SoFieldData_getNumFields, METH_O, "SoFieldData_getNumFields(SoFieldData self) -> int"},
	 { "SoFieldData_getFieldName", _wrap_SoFieldData_getFieldName, METH_VARARGS, "SoFieldData_getFieldName(SoFieldData self, int index) -> SbName"},
	 { "SoFieldData_getField", _wrap_SoFieldData_getField, METH_VARARGS, "SoFieldData_getField(SoFieldData self, SoFieldContainer object, int index) -> SoField"},
	 { "SoFieldData_getIndex", _wrap_SoFieldData_getIndex, METH_VARARGS, "SoFieldData_getIndex(SoFieldData self, SoFieldContainer fc, SoField field) -> int"},
	 { "SoFieldData_addEnumValue", _wrap_SoFieldData_addEnumValue, METH_VARARGS, "SoFieldData_addEnumValue(SoFieldData self, char const * enumname, char const * valuename, int value)"},
	 { "SoFieldData_getEnumData", _wrap_SoFieldData_getEnumData, METH_VARARGS, "SoFieldData_getEnumData(SoFieldData self, char const * enumname, int & num, int const *& values, SbName const *& names)"},
	 { "SoFieldData_read", _wrap_SoFieldData_read, METH_VARARGS, "\n"
		"SoFieldData_read(SoFieldData self, SoInput input, SoFieldContainer object, SbBool erroronunknownfield, SbBool & notbuiltin) -> SbBool\n"
		"SoFieldData_read(SoFieldData self, SoInput input, SoFieldContainer object, SbName fieldname, SbBool & foundname) -> SbBool\n"
		""},
	 { "SoFieldData_write", _wrap_SoFieldData_write, METH_VARARGS, "SoFieldData_write(SoFieldData self, SoOutput out, SoFieldContainer object)"},
	 { "SoFieldData_copy", _wrap_SoFieldData_copy, METH_VARARGS, "SoFieldData_copy(SoFieldData self, SoFieldData src)"},
	 { "SoFieldData_isSame", _wrap_SoFieldData_isSame, METH_VARARGS, "SoFieldData_isSame(SoFieldData self, SoFieldContainer c1, SoFieldContainer c2) -> SbBool"},
	 { "SoFieldData_readFieldDescriptions", _wrap_SoFieldData_readFieldDescriptions, METH_VARARGS, "SoFieldData_readFieldDescriptions(SoFieldData self, SoInput input, SoFieldContainer object, int numdescriptionsexpected, SbBool const readfieldvalues=1) -> SbBool"},
	 { "SoFieldData_writeFieldDescriptions", _wrap_SoFieldData_writeFieldDescriptions, METH_VARARGS, "SoFieldData_writeFieldDescriptions(SoFieldData self, SoOutput out, SoFieldContainer object)"},
	 { "SoFieldData_swigregister", SoFieldData_swigregister, METH_O, NULL},
	 { "SoFieldData_swiginit", SoFieldData_swiginit, METH_VARARGS, NULL},
	 { "SoFieldContainer_initClass", _wrap_SoFieldContainer_initClass, METH_NOARGS, "SoFieldContainer_initClass()"},
	 { "SoFieldContainer_getClassTypeId", _wrap_SoFieldContainer_getClassTypeId, METH_NOARGS, "SoFieldContainer_getClassTypeId() -> SoType"},
	 { "SoFieldContainer_cleanupClass", _wrap_SoFieldContainer_cleanupClass, METH_NOARGS, "SoFieldContainer_cleanupClass()"},
	 { "SoFieldContainer_setToDefaults", _wrap_SoFieldContainer_setToDefaults, METH_O, "SoFieldContainer_setToDefaults(SoFieldContainer self)"},
	 { "SoFieldContainer_hasDefaultValues", _wrap_SoFieldContainer_hasDefaultValues, METH_O, "SoFieldContainer_hasDefaultValues(SoFieldContainer self) -> SbBool"},
	 { "SoFieldContainer_fieldsAreEqual", _wrap_SoFieldContainer_fieldsAreEqual, METH_VARARGS, "SoFieldContainer_fieldsAreEqual(SoFieldContainer self, SoFieldContainer container) -> SbBool"},
	 { "SoFieldContainer_copyFieldValues", _wrap_SoFieldContainer_copyFieldValues, METH_VARARGS, "SoFieldContainer_copyFieldValues(SoFieldContainer self, SoFieldContainer container, SbBool copyconnections=0)"},
	 { "SoFieldContainer_getFields", _wrap_SoFieldContainer_getFields, METH_VARARGS, "SoFieldContainer_getFields(SoFieldContainer self, SoFieldList l) -> int"},
	 { "SoFieldContainer_getAllFields", _wrap_SoFieldContainer_getAllFields, METH_VARARGS, "SoFieldContainer_getAllFields(SoFieldContainer self, SoFieldList l) -> int"},
	 { "SoFieldContainer_getField", _wrap_SoFieldContainer_getField, METH_VARARGS, "SoFieldContainer_getField(SoFieldContainer self, SbName name) -> SoField"},
	 { "SoFieldContainer_getEventIn", _wrap_SoFieldContainer_getEventIn, METH_VARARGS, "SoFieldContainer_getEventIn(SoFieldContainer self, SbName name) -> SoField"},
	 { "SoFieldContainer_getEventOut", _wrap_SoFieldContainer_getEventOut, METH_VARARGS, "SoFieldContainer_getEventOut(SoFieldContainer self, SbName name) -> SoField"},
	 { "SoFieldContainer_enableNotify", _wrap_SoFieldContainer_enableNotify, METH_VARARGS, "SoFieldContainer_enableNotify(SoFieldContainer self, SbBool const flag) -> SbBool"},
	 { "SoFieldContainer_isNotifyEnabled", _wrap_SoFieldContainer_isNotifyEnabled, METH_O, "SoFieldContainer_isNotifyEnabled(SoFieldContainer self) -> SbBool"},
	 { "SoFieldContainer_set", _wrap_SoFieldContainer_set, METH_VARARGS, "\n"
		"SoFieldContainer_set(SoFieldContainer self, char const *const fielddata) -> SbBool\n"
		"SoFieldContainer_set(SoFieldContainer self, char const * fielddata, SoInput input) -> SbBool\n"
		""},
	 { "SoFieldContainer_get", _wrap_SoFieldContainer_get, METH_VARARGS, "\n"
		"SoFieldContainer_get(SoFieldContainer self, SbString fielddata)\n"
		"SoFieldContainer_get(SoFieldContainer self, SbString fielddata, SoOutput out)\n"
		""},
	 { "SoFieldContainer_notify", _wrap_SoFieldContainer_notify, METH_VARARGS, "SoFieldContainer_notify(SoFieldContainer self, SoNotList l)"},
	 { "SoFieldContainer_validateNewFieldValue", _wrap_SoFieldContainer_validateNewFieldValue, METH_VARARGS, "SoFieldContainer_validateNewFieldValue(SoFieldContainer self, SoField field, void * newval) -> SbBool"},
	 { "SoFieldContainer_addWriteReference", _wrap_SoFieldContainer_addWriteReference, METH_VARARGS, "SoFieldContainer_addWriteReference(SoFieldContainer self, SoOutput out, SbBool isfromfield=0)"},
	 { "SoFieldContainer_writeInstance", _wrap_SoFieldContainer_writeInstance, METH_VARARGS, "SoFieldContainer_writeInstance(SoFieldContainer self, SoOutput out)"},
	 { "SoFieldContainer_getIsBuiltIn", _wrap_SoFieldContainer_getIsBuiltIn, METH_O, "SoFieldContainer_getIsBuiltIn(SoFieldContainer self) -> SbBool"},
	 { "SoFieldContainer_getFieldData", _wrap_SoFieldContainer_getFieldData, METH_O, "SoFieldContainer_getFieldData(SoFieldContainer self) -> SoFieldData"},
	 { "SoFieldContainer_copyContents", _wrap_SoFieldContainer_copyContents, METH_VARARGS, "SoFieldContainer_copyContents(SoFieldContainer self, SoFieldContainer srcFrom, SbBool copyconnections)"},
	 { "SoFieldContainer_copyThroughConnection", _wrap_SoFieldContainer_copyThroughConnection, METH_O, "SoFieldContainer_copyThroughConnection(SoFieldContainer self) -> SoFieldContainer"},
	 { "SoFieldContainer_initCopyDict", _wrap_SoFieldContainer_initCopyDict, METH_NOARGS, "SoFieldContainer_initCopyDict()"},
	 { "SoFieldContainer_addCopy", _wrap_SoFieldContainer_addCopy, METH_VARARGS, "SoFieldContainer_addCopy(SoFieldContainer orig, SoFieldContainer copy)"},
	 { "SoFieldContainer_checkCopy", _wrap_SoFieldContainer_checkCopy, METH_O, "SoFieldContainer_checkCopy(SoFieldContainer orig) -> SoFieldContainer"},
	 { "SoFieldContainer_findCopy", _wrap_SoFieldContainer_findCopy, METH_VARARGS, "SoFieldContainer_findCopy(SoFieldContainer orig, SbBool const copyconnections) -> SoFieldContainer"},
	 { "SoFieldContainer_copyDone", _wrap_SoFieldContainer_copyDone, METH_NOARGS, "SoFieldContainer_copyDone()"},
	 { "SoFieldContainer_getFieldsMemorySize", _wrap_SoFieldContainer_getFieldsMemorySize, METH_VARARGS, "SoFieldContainer_getFieldsMemorySize(SoFieldContainer self, size_t & managed, size_t & unmanaged)"},
	 { "SoFieldContainer_setUserData", _wrap_SoFieldContainer_setUserData, METH_VARARGS, "SoFieldContainer_setUserData(SoFieldContainer self, void * userdata)"},
	 { "SoFieldContainer_getUserData", _wrap_SoFieldContainer_getUserData, METH_O, "SoFieldContainer_getUserData(SoFieldContainer self) -> void *"},
	 { "SoFieldContainer_getFieldName", _wrap_SoFieldContainer_getFieldName, METH_VARARGS, "\n"
		"SoFieldContainer_getFieldName(SoFieldContainer self, SoField field, SbName name) -> SbBool\n"
		"SoFieldContainer_getFieldName(SoFieldContainer self, SoField field) -> PyObject *\n"
		""},
	 { "SoFieldContainer_swigregister", SoFieldContainer_swigregister, METH_O, NULL},
	 { "SoNode_setOverride", _wrap_SoNode_setOverride, METH_VARARGS, "SoNode_setOverride(SoNode self, SbBool const state)"},
	 { "SoNode_isOverride", _wrap_SoNode_isOverride, METH_O, "SoNode_isOverride(SoNode self) -> SbBool"},
	 { "SoNode_getCompatibilityTypes", _wrap_SoNode_getCompatibilityTypes, METH_O, "SoNode_getCompatibilityTypes(SoType nodetype) -> uint32_t"},
	 { "SoNode_setNodeType", _wrap_SoNode_setNodeType, METH_VARARGS, "SoNode_setNodeType(SoNode self, SoNode::NodeType const type)"},
	 { "SoNode_getNodeType", _wrap_SoNode_getNodeType, METH_O, "SoNode_getNodeType(SoNode self) -> SoNode::NodeType"},
	 { "SoNode_copy", _wrap_SoNode_copy, METH_VARARGS, "SoNode_copy(SoNode self, SbBool copyconnections=0) -> SoNode"},
	 { "SoNode_affectsState", _wrap_SoNode_affectsState, METH_O, "SoNode_affectsState(SoNode self) -> SbBool"},
	 { "SoNode_doAction", _wrap_SoNode_doAction, METH_VARARGS, "SoNode_doAction(SoNode self, SoAction action)"},
	 { "SoNode_GLRender", _wrap_SoNode_GLRender, METH_VARARGS, "SoNode_GLRender(SoNode self, SoGLRenderAction action)"},
	 { "SoNode_GLRenderBelowPath", _wrap_SoNode_GLRenderBelowPath, METH_VARARGS, "SoNode_GLRenderBelowPath(SoNode self, SoGLRenderAction action)"},
	 { "SoNode_GLRenderInPath", _wrap_SoNode_GLRenderInPath, METH_VARARGS, "SoNode_GLRenderInPath(SoNode self, SoGLRenderAction action)"},
	 { "SoNode_GLRenderOffPath", _wrap_SoNode_GLRenderOffPath, METH_VARARGS, "SoNode_GLRenderOffPath(SoNode self, SoGLRenderAction action)"},
	 { "SoNode_callback", _wrap_SoNode_callback, METH_VARARGS, "SoNode_callback(SoNode self, SoCallbackAction action)"},
	 { "SoNode_getBoundingBox", _wrap_SoNode_getBoundingBox, METH_VARARGS, "SoNode_getBoundingBox(SoNode self, SoGetBoundingBoxAction action)"},
	 { "SoNode_getMatrix", _wrap_SoNode_getMatrix, METH_VARARGS, "SoNode_getMatrix(SoNode self, SoGetMatrixAction action)"},
	 { "SoNode_handleEvent", _wrap_SoNode_handleEvent, METH_VARARGS, "SoNode_handleEvent(SoNode self, SoHandleEventAction action)"},
	 { "SoNode_pick", _wrap_SoNode_pick, METH_VARARGS, "SoNode_pick(SoNode self, SoPickAction action)"},
	 { "SoNode_rayPick", _wrap_SoNode_rayPick, METH_VARARGS, "SoNode_rayPick(SoNode self, SoRayPickAction action)"},
	 { "SoNode_search", _wrap_SoNode_search, METH_VARARGS, "SoNode_search(SoNode self, SoSearchAction action)"},
	 { "SoNode_write", _wrap_SoNode_write, METH_VARARGS, "SoNode_write(SoNode self, SoWriteAction action)"},
	 { "SoNode_audioRender", _wrap_SoNode_audioRender, METH_VARARGS, "SoNode_audioRender(SoNode self, SoAudioRenderAction action)"},
	 { "SoNode_getPrimitiveCount", _wrap_SoNode_getPrimitiveCount, METH_VARARGS, "SoNode_getPrimitiveCount(SoNode self, SoGetPrimitiveCountAction action)"},
	 { "SoNode_grabEventsSetup", _wrap_SoNode_grabEventsSetup, METH_O, "SoNode_grabEventsSetup(SoNode self)"},
	 { "SoNode_grabEventsCleanup", _wrap_SoNode_grabEventsCleanup, METH_O, "SoNode_grabEventsCleanup(SoNode self)"},
	 { "SoNode_startNotify", _wrap_SoNode_startNotify, METH_O, "SoNode_startNotify(SoNode self)"},
	 { "SoNode_notify", _wrap_SoNode_notify, METH_VARARGS, "SoNode_notify(SoNode self, SoNotList l)"},
	 { "SoNode_getNodeId", _wrap_SoNode_getNodeId, METH_O, "SoNode_getNodeId(SoNode self) -> SbUniqueId"},
	 { "SoNode_getChildren", _wrap_SoNode_getChildren, METH_O, "SoNode_getChildren(SoNode self) -> SoChildList"},
	 { "SoNode_writeInstance", _wrap_SoNode_writeInstance, METH_VARARGS, "SoNode_writeInstance(SoNode self, SoOutput out)"},
	 { "SoNode_addToCopyDict", _wrap_SoNode_addToCopyDict, METH_O, "SoNode_addToCopyDict(SoNode self) -> SoNode"},
	 { "SoNode_copyContents", _wrap_SoNode_copyContents, METH_VARARGS, "SoNode_copyContents(SoNode self, SoFieldContainer srcFrom, SbBool copyconnections)"},
	 { "SoNode_copyThroughConnection", _wrap_SoNode_copyThroughConnection, METH_O, "SoNode_copyThroughConnection(SoNode self) -> SoFieldContainer"},
	 { "SoNode_getClassTypeId", _wrap_SoNode_getClassTypeId, METH_NOARGS, "SoNode_getClassTypeId() -> SoType"},
	 { "SoNode_getByName", _wrap_SoNode_getByName, METH_VARARGS, "\n"
		"SoNode_getByName(SbName name) -> SoNode\n"
		"SoNode_getByName(SbName name, SoNodeList l) -> int\n"
		""},
	 { "SoNode_initClass", _wrap_SoNode_initClass, METH_NOARGS, "SoNode_initClass()"},
	 { "SoNode_initClasses", _wrap_SoNode_initClasses, METH_NOARGS, "SoNode_initClasses()"},
	 { "SoNode_getNextNodeId", _wrap_SoNode_getNextNodeId, METH_NOARGS, "SoNode_getNextNodeId() -> SbUniqueId"},
	 { "SoNode_getActionMethodIndex", _wrap_SoNode_getActionMethodIndex, METH_O, "SoNode_getActionMethodIndex(SoType type) -> int"},
	 { "SoNode_getBoundingBoxS", _wrap_SoNode_getBoundingBoxS, METH_VARARGS, "SoNode_getBoundingBoxS(SoAction action, SoNode node)"},
	 { "SoNode_GLRenderS", _wrap_SoNode_GLRenderS, METH_VARARGS, "SoNode_GLRenderS(SoAction action, SoNode node)"},
	 { "SoNode_callbackS", _wrap_SoNode_callbackS, METH_VARARGS, "SoNode_callbackS(SoAction action, SoNode node)"},
	 { "SoNode_getMatrixS", _wrap_SoNode_getMatrixS, METH_VARARGS, "SoNode_getMatrixS(SoAction action, SoNode node)"},
	 { "SoNode_handleEventS", _wrap_SoNode_handleEventS, METH_VARARGS, "SoNode_handleEventS(SoAction action, SoNode node)"},
	 { "SoNode_pickS", _wrap_SoNode_pickS, METH_VARARGS, "SoNode_pickS(SoAction action, SoNode node)"},
	 { "SoNode_rayPickS", _wrap_SoNode_rayPickS, METH_VARARGS, "SoNode_rayPickS(SoAction action, SoNode node)"},
	 { "SoNode_searchS", _wrap_SoNode_searchS, METH_VARARGS, "SoNode_searchS(SoAction action, SoNode node)"},
	 { "SoNode_writeS", _wrap_SoNode_writeS, METH_VARARGS, "SoNode_writeS(SoAction action, SoNode node)"},
	 { "SoNode_audioRenderS", _wrap_SoNode_audioRenderS, METH_VARARGS, "SoNode_audioRenderS(SoAction action, SoNode node)"},
	 { "SoNode_getPrimitiveCountS", _wrap_SoNode_getPrimitiveCountS, METH_VARARGS, "SoNode_getPrimitiveCountS(SoAction action, SoNode node)"},
	 { "SoNode_swigregister", SoNode_swigregister, METH_O, NULL},
	 { "new_SoSensorManager", _wrap_new_SoSensorManager, METH_NOARGS, "new_SoSensorManager() -> SoSensorManager"},
	 { "delete_SoSensorManager", _wrap_delete_SoSensorManager, METH_O, "delete_SoSensorManager(SoSensorManager self)"},
	 { "SoSensorManager_insertDelaySensor", _wrap_SoSensorManager_insertDelaySensor, METH_VARARGS, "SoSensorManager_insertDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"},
	 { "SoSensorManager_insertTimerSensor", _wrap_SoSensorManager_insertTimerSensor, METH_VARARGS, "SoSensorManager_insertTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"},
	 { "SoSensorManager_removeDelaySensor", _wrap_SoSensorManager_removeDelaySensor, METH_VARARGS, "SoSensorManager_removeDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"},
	 { "SoSensorManager_removeTimerSensor", _wrap_SoSensorManager_removeTimerSensor, METH_VARARGS, "SoSensorManager_removeTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"},
	 { "SoSensorManager_rescheduleTimer", _wrap_SoSensorManager_rescheduleTimer, METH_VARARGS, "SoSensorManager_rescheduleTimer(SoSensorManager self, SoTimerSensor s)"},
	 { "SoSensorManager_removeRescheduledTimer", _wrap_SoSensorManager_removeRescheduledTimer, METH_VARARGS, "SoSensorManager_removeRescheduledTimer(SoSensorManager self, SoTimerQueueSensor s)"},
	 { "SoSensorManager_processDelayQueue", _wrap_SoSensorManager_processDelayQueue, METH_VARARGS, "SoSensorManager_processDelayQueue(SoSensorManager self, SbBool isidle)"},
	 { "SoSensorManager_processImmediateQueue", _wrap_SoSensorManager_processImmediateQueue, METH_O, "SoSensorManager_processImmediateQueue(SoSensorManager self)"},
	 { "SoSensorManager_processTimerQueue", _wrap_SoSensorManager_processTimerQueue, METH_O, "SoSensorManager_processTimerQueue(SoSensorManager self)"},
	 { "SoSensorManager_isDelaySensorPending", _wrap_SoSensorManager_isDelaySensorPending, METH_O, "SoSensorManager_isDelaySensorPending(SoSensorManager self) -> SbBool"},
	 { "SoSensorManager_setDelaySensorTimeout", _wrap_SoSensorManager_setDelaySensorTimeout, METH_VARARGS, "SoSensorManager_setDelaySensorTimeout(SoSensorManager self, SbTime t)"},
	 { "SoSensorManager_getDelaySensorTimeout", _wrap_SoSensorManager_getDelaySensorTimeout, METH_O, "SoSensorManager_getDelaySensorTimeout(SoSensorManager self) -> SbTime"},
	 { "SoSensorManager_doSelect", _wrap_SoSensorManager_doSelect, METH_VARARGS, "SoSensorManager_doSelect(SoSensorManager self, int nfds, void * readfds, void * writefds, void * exceptfds, timeval * userTimeOut) -> int"},
	 { "SoSensorManager_setChangedCallback", _wrap_SoSensorManager_setChangedCallback, METH_VARARGS, "\n"
		"SoSensorManager_setChangedCallback(SoSensorManager self, void (*)(void *) sensorQueueChangedCB, void * data)\n"
		"SoSensorManager_setChangedCallback(SoSensorManager self, PyObject * pyfunc, PyObject * data)\n"
		""},
	 { "SoSensorManager_isTimerSensorPending", _wrap_SoSensorManager_isTimerSensorPending, METH_VARARGS, "\n"
		"SoSensorManager_isTimerSensorPending(SoSensorManager self, SbTime tm) -> SbBool\n"
		"SoSensorManager_isTimerSensorPending(SoSensorManager self) -> PyObject *\n"
		""},
	 { "SoSensorManager_swigregister", SoSensorManager_swigregister, METH_O, NULL},
	 { "SoSensorManager_swiginit", SoSensorManager_swiginit, METH_VARARGS, NULL},
	 { "SoDB_init", _wrap_SoDB_init, METH_NOARGS, "SoDB_init()"},
	 { "SoDB_finish", _wrap_SoDB_finish, METH_NOARGS, "SoDB_finish()"},
	 { "SoDB_cleanup", _wrap_SoDB_cleanup, METH_NOARGS, "SoDB_cleanup()"},
	 { "SoDB_getVersion", _wrap_SoDB_getVersion, METH_NOARGS, "SoDB_getVersion() -> char const *"},
	 { "SoDB_read", _wrap_SoDB_read, METH_VARARGS, "\n"
		"SoDB_read(SoInput input, SoPath *& path) -> SbBool\n"
		"SoDB_read(SoInput input, SoBase *& base) -> SbBool\n"
		"SoDB_read(SoInput input, SoNode *& rootnode) -> SbBool\n"
		""},
	 { "SoDB_readAll", _wrap_SoDB_readAll, METH_O, "SoDB_readAll(SoInput input) -> SoSeparator"},
	 { "SoDB_readAllVRML", _wrap_SoDB_readAllVRML, METH_O, "SoDB_readAllVRML(SoInput input) -> SoVRMLGroup"},
	 { "SoDB_isValidHeader", _wrap_SoDB_isValidHeader, METH_O, "SoDB_isValidHeader(char const * teststring) -> SbBool"},
	 { "SoDB_registerHeader", _wrap_SoDB_registerHeader, METH_VARARGS, "SoDB_registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback, void * userdata=None) -> SbBool"},
	 { "SoDB_getHeaderData", _wrap_SoDB_getHeaderData, METH_VARARGS, "SoDB_getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata, SbBool substringok=0) -> SbBool"},
	 { "SoDB_getNumHeaders", _wrap_SoDB_getNumHeaders, METH_NOARGS, "SoDB_getNumHeaders() -> int"},
	 { "SoDB_getHeaderString", _wrap_SoDB_getHeaderString, METH_O, "SoDB_getHeaderString(int const i) -> SbString"},
	 { "SoDB_createGlobalField", _wrap_SoDB_createGlobalField, METH_VARARGS, "SoDB_createGlobalField(SbName name, SoType type) -> SoField"},
	 { "SoDB_getGlobalField", _wrap_SoDB_getGlobalField, METH_O, "SoDB_getGlobalField(SbName name) -> SoField"},
	 { "SoDB_renameGlobalField", _wrap_SoDB_renameGlobalField, METH_VARARGS, "SoDB_renameGlobalField(SbName srcFrom, SbName destTo)"},
	 { "SoDB_setRealTimeInterval", _wrap_SoDB_setRealTimeInterval, METH_O, "SoDB_setRealTimeInterval(SbTime interval)"},
	 { "SoDB_getRealTimeInterval", _wrap_SoDB_getRealTimeInterval, METH_NOARGS, "SoDB_getRealTimeInterval() -> SbTime"},
	 { "SoDB_enableRealTimeSensor", _wrap_SoDB_enableRealTimeSensor, METH_O, "SoDB_enableRealTimeSensor(SbBool on)"},
	 { "SoDB_getSensorManager", _wrap_SoDB_getSensorManager, METH_NOARGS, "SoDB_getSensorManager() -> SoSensorManager"},
	 { "SoDB_setDelaySensorTimeout", _wrap_SoDB_setDelaySensorTimeout, METH_O, "SoDB_setDelaySensorTimeout(SbTime t)"},
	 { "SoDB_getDelaySensorTimeout", _wrap_SoDB_getDelaySensorTimeout, METH_NOARGS, "SoDB_getDelaySensorTimeout() -> SbTime"},
	 { "SoDB_doSelect", _wrap_SoDB_doSelect, METH_VARARGS, "SoDB_doSelect(int nfds, void * readfds, void * writefds, void * exceptfds, timeval * usertimeout) -> int"},
	 { "SoDB_addConverter", _wrap_SoDB_addConverter, METH_VARARGS, "SoDB_addConverter(SoType srcFrom, SoType destTo, SoType converter)"},
	 { "SoDB_getConverter", _wrap_SoDB_getConverter, METH_VARARGS, "SoDB_getConverter(SoType srcFrom, SoType destTo) -> SoType"},
	 { "SoDB_isInitialized", _wrap_SoDB_isInitialized, METH_NOARGS, "SoDB_isInitialized() -> SbBool"},
	 { "SoDB_startNotify", _wrap_SoDB_startNotify, METH_NOARGS, "SoDB_startNotify()"},
	 { "SoDB_isNotifying", _wrap_SoDB_isNotifying, METH_NOARGS, "SoDB_isNotifying() -> SbBool"},
	 { "SoDB_endNotify", _wrap_SoDB_endNotify, METH_NOARGS, "SoDB_endNotify()"},
	 { "SoDB_addProgressCallback", _wrap_SoDB_addProgressCallback, METH_VARARGS, "SoDB_addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"},
	 { "SoDB_removeProgressCallback", _wrap_SoDB_removeProgressCallback, METH_VARARGS, "SoDB_removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"},
	 { "SoDB_isMultiThread", _wrap_SoDB_isMultiThread, METH_NOARGS, "SoDB_isMultiThread() -> SbBool"},
	 { "SoDB_readlock", _wrap_SoDB_readlock, METH_NOARGS, "SoDB_readlock()"},
	 { "SoDB_readunlock", _wrap_SoDB_readunlock, METH_NOARGS, "SoDB_readunlock()"},
	 { "SoDB_writelock", _wrap_SoDB_writelock, METH_NOARGS, "SoDB_writelock()"},
	 { "SoDB_writeunlock", _wrap_SoDB_writeunlock, METH_NOARGS, "SoDB_writeunlock()"},
	 { "SoDB_createRoute", _wrap_SoDB_createRoute, METH_VARARGS, "SoDB_createRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"},
	 { "SoDB_removeRoute", _wrap_SoDB_removeRoute, METH_VARARGS, "SoDB_removeRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"},
	 { "new_SoDB", _wrap_new_SoDB, METH_NOARGS, "new_SoDB() -> SoDB"},
	 { "delete_SoDB", _wrap_delete_SoDB, METH_O, "delete_SoDB(SoDB self)"},
	 { "SoDB_swigregister", SoDB_swigregister, METH_O, NULL},
	 { "SoDB_swiginit", SoDB_swiginit, METH_VARARGS, NULL},
	 { "new_SoInput", _wrap_new_SoInput, METH_VARARGS, "\n"
		"SoInput()\n"
		"new_SoInput(SoInput dictIn) -> SoInput\n"
		""},
	 { "SoInput_findProto", _wrap_SoInput_findProto, METH_VARARGS, "SoInput_findProto(SoInput self, SbName name) -> SoProto"},
	 { "SoInput_addProto", _wrap_SoInput_addProto, METH_VARARGS, "SoInput_addProto(SoInput self, SoProto proto)"},
	 { "SoInput_pushProto", _wrap_SoInput_pushProto, METH_VARARGS, "SoInput_pushProto(SoInput self, SoProto proto)"},
	 { "SoInput_getCurrentProto", _wrap_SoInput_getCurrentProto, METH_O, "SoInput_getCurrentProto(SoInput self) -> SoProto"},
	 { "SoInput_popProto", _wrap_SoInput_popProto, METH_O, "SoInput_popProto(SoInput self)"},
	 { "SoInput_addRoute", _wrap_SoInput_addRoute, METH_VARARGS, "SoInput_addRoute(SoInput self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"},
	 { "SoInput_checkISReference", _wrap_SoInput_checkISReference, METH_VARARGS, "SoInput_checkISReference(SoInput self, SoFieldContainer container, SbName fieldname, SbBool & readok) -> SbBool"},
	 { "delete_SoInput", _wrap_delete_SoInput, METH_O, "delete_SoInput(SoInput self)"},
	 { "SoInput_setFilePointer", _wrap_SoInput_setFilePointer, METH_VARARGS, "SoInput_setFilePointer(SoInput self, FILE * newFP)"},
	 { "SoInput_openFile", _wrap_SoInput_openFile, METH_VARARGS, "SoInput_openFile(SoInput self, char const * fileName, SbBool okIfNotFound=0) -> SbBool"},
	 { "SoInput_pushFile", _wrap_SoInput_pushFile, METH_VARARGS, "SoInput_pushFile(SoInput self, char const * fileName) -> SbBool"},
	 { "SoInput_closeFile", _wrap_SoInput_closeFile, METH_O, "SoInput_closeFile(SoInput self)"},
	 { "SoInput_isValidFile", _wrap_SoInput_isValidFile, METH_O, "SoInput_isValidFile(SoInput self) -> SbBool"},
	 { "SoInput_isValidBuffer", _wrap_SoInput_isValidBuffer, METH_O, "SoInput_isValidBuffer(SoInput self) -> SbBool"},
	 { "SoInput_getCurFile", _wrap_SoInput_getCurFile, METH_O, "SoInput_getCurFile(SoInput self) -> FILE *"},
	 { "SoInput_getCurFileName", _wrap_SoInput_getCurFileName, METH_O, "SoInput_getCurFileName(SoInput self) -> char const *"},
	 { "SoInput_setBuffer", _wrap_SoInput_setBuffer, METH_VARARGS, "SoInput_setBuffer(SoInput self, void const * bufpointer)"},
	 { "SoInput_setStringArray", _wrap_SoInput_setStringArray, METH_VARARGS, "SoInput_setStringArray(SoInput self, char const *[] strings)"},
	 { "SoInput_getNumBytesRead", _wrap_SoInput_getNumBytesRead, METH_O, "SoInput_getNumBytesRead(SoInput self) -> size_t"},
	 { "SoInput_getHeader", _wrap_SoInput_getHeader, METH_O, "SoInput_getHeader(SoInput self) -> SbString"},
	 { "SoInput_getIVVersion", _wrap_SoInput_getIVVersion, METH_O, "SoInput_getIVVersion(SoInput self) -> float"},
	 { "SoInput_isBinary", _wrap_SoInput_isBinary, METH_O, "SoInput_isBinary(SoInput self) -> SbBool"},
	 { "SoInput_get", _wrap_SoInput_get, METH_VARARGS, "SoInput_get(SoInput self, char & c) -> SbBool"},
	 { "SoInput_getASCIIBuffer", _wrap_SoInput_getASCIIBuffer, METH_VARARGS, "SoInput_getASCIIBuffer(SoInput self, char & c) -> SbBool"},
	 { "SoInput_getASCIIFile", _wrap_SoInput_getASCIIFile, METH_VARARGS, "SoInput_getASCIIFile(SoInput self, char & c) -> SbBool"},
	 { "SoInput_readHex", _wrap_SoInput_readHex, METH_VARARGS, "SoInput_readHex(SoInput self, uint32_t & l) -> SbBool"},
	 { "SoInput_read", _wrap_SoInput_read, METH_VARARGS, "\n"
		"SoInput_read(SoInput self, char & c) -> SbBool\n"
		"SoInput_read(SoInput self, char & c, SbBool skip) -> SbBool\n"
		"SoInput_read(SoInput self, SbString s) -> SbBool\n"
		"SoInput_read(SoInput self, SbName n, SbBool validIdent=0) -> SbBool\n"
		"SoInput_read(SoInput self, int & i) -> SbBool\n"
		"SoInput_read(SoInput self, unsigned int & i) -> SbBool\n"
		"SoInput_read(SoInput self, short & s) -> SbBool\n"
		"SoInput_read(SoInput self, unsigned short & s) -> SbBool\n"
		"SoInput_read(SoInput self, float & f) -> SbBool\n"
		"SoInput_read(SoInput self, double & d) -> SbBool\n"
		""},
	 { "SoInput_readByte", _wrap_SoInput_readByte, METH_VARARGS, "\n"
		"SoInput_readByte(SoInput self, int8_t & b) -> SbBool\n"
		"SoInput_readByte(SoInput self, uint8_t & b) -> SbBool\n"
		""},
	 { "SoInput_readBinaryArray", _wrap_SoInput_readBinaryArray, METH_VARARGS, "\n"
		"SoInput_readBinaryArray(SoInput self, unsigned char * c, int length) -> SbBool\n"
		"SoInput_readBinaryArray(SoInput self, int32_t * l, int length) -> SbBool\n"
		"SoInput_readBinaryArray(SoInput self, float * f, int length) -> SbBool\n"
		"SoInput_readBinaryArray(SoInput self, double * d, int length) -> SbBool\n"
		""},
	 { "SoInput_eof", _wrap_SoInput_eof, METH_O, "SoInput_eof(SoInput self) -> SbBool"},
	 { "SoInput_isFileVRML1", _wrap_SoInput_isFileVRML1, METH_O, "SoInput_isFileVRML1(SoInput self) -> SbBool"},
	 { "SoInput_isFileVRML2", _wrap_SoInput_isFileVRML2, METH_O, "SoInput_isFileVRML2(SoInput self) -> SbBool"},
	 { "SoInput_resetFilePointer", _wrap_SoInput_resetFilePointer, METH_VARARGS, "SoInput_resetFilePointer(SoInput self, FILE * fptr)"},
	 { "SoInput_getLocationString", _wrap_SoInput_getLocationString, METH_VARARGS, "SoInput_getLocationString(SoInput self, SbString string)"},
	 { "SoInput_putBack", _wrap_SoInput_putBack, METH_VARARGS, "\n"
		"SoInput_putBack(SoInput self, char const c)\n"
		"SoInput_putBack(SoInput self, char const * str)\n"
		""},
	 { "SoInput_addReference", _wrap_SoInput_addReference, METH_VARARGS, "SoInput_addReference(SoInput self, SbName name, SoBase base, SbBool addToGlobalDict=1)"},
	 { "SoInput_removeReference", _wrap_SoInput_removeReference, METH_VARARGS, "SoInput_removeReference(SoInput self, SbName name)"},
	 { "SoInput_findReference", _wrap_SoInput_findReference, METH_VARARGS, "SoInput_findReference(SoInput self, SbName name) -> SoBase"},
	 { "SoInput_addDirectoryFirst", _wrap_SoInput_addDirectoryFirst, METH_O, "SoInput_addDirectoryFirst(char const * dirName)"},
	 { "SoInput_addDirectoryLast", _wrap_SoInput_addDirectoryLast, METH_O, "SoInput_addDirectoryLast(char const * dirName)"},
	 { "SoInput_addEnvDirectoriesFirst", _wrap_SoInput_addEnvDirectoriesFirst, METH_VARARGS, "SoInput_addEnvDirectoriesFirst(char const * envVarName, char const * separator=\":\\t \")"},
	 { "SoInput_addEnvDirectoriesLast", _wrap_SoInput_addEnvDirectoriesLast, METH_VARARGS, "SoInput_addEnvDirectoriesLast(char const * envVarName, char const * separator=\":\\t \")"},
	 { "SoInput_removeDirectory", _wrap_SoInput_removeDirectory, METH_O, "SoInput_removeDirectory(char const * dirName)"},
	 { "SoInput_clearDirectories", _wrap_SoInput_clearDirectories, METH_NOARGS, "SoInput_clearDirectories()"},
	 { "SoInput_getDirectories", _wrap_SoInput_getDirectories, METH_NOARGS, "SoInput_getDirectories() -> SbStringList"},
	 { "SoInput_init", _wrap_SoInput_init, METH_NOARGS, "SoInput_init()"},
	 { "SoInput_getPathname", _wrap_SoInput_getPathname, METH_VARARGS, "\n"
		"SoInput_getPathname(char const *const filename) -> SbString\n"
		"SoInput_getPathname(SbString s) -> SbString\n"
		""},
	 { "SoInput_getBasename", _wrap_SoInput_getBasename, METH_VARARGS, "\n"
		"SoInput_getBasename(char const *const filename) -> SbString\n"
		"SoInput_getBasename(SbString s) -> SbString\n"
		""},
	 { "SoInput_searchForFile", _wrap_SoInput_searchForFile, METH_VARARGS, "SoInput_searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"},
	 { "SoInput_swigregister", SoInput_swigregister, METH_O, NULL},
	 { "SoInput_swiginit", SoInput_swiginit, METH_VARARGS, NULL},
	 { "new_SoOutput", _wrap_new_SoOutput, METH_VARARGS, "\n"
		"SoOutput()\n"
		"new_SoOutput(SoOutput dictOut) -> SoOutput\n"
		""},
	 { "delete_SoOutput", _wrap_delete_SoOutput, METH_O, "delete_SoOutput(SoOutput self)"},
	 { "SoOutput_setFilePointer", _wrap_SoOutput_setFilePointer, METH_VARARGS, "SoOutput_setFilePointer(SoOutput self, FILE * newFP)"},
	 { "SoOutput_getFilePointer", _wrap_SoOutput_getFilePointer, METH_O, "SoOutput_getFilePointer(SoOutput self) -> FILE *"},
	 { "SoOutput_openFile", _wrap_SoOutput_openFile, METH_VARARGS, "SoOutput_openFile(SoOutput self, char const *const fileName) -> SbBool"},
	 { "SoOutput_closeFile", _wrap_SoOutput_closeFile, METH_O, "SoOutput_closeFile(SoOutput self)"},
	 { "SoOutput_setCompression", _wrap_SoOutput_setCompression, METH_VARARGS, "SoOutput_setCompression(SoOutput self, SbName compmethod, float const level=0.5) -> SbBool"},
	 { "SoOutput_getAvailableCompressionMethods", _wrap_SoOutput_getAvailableCompressionMethods, METH_O, "SoOutput_getAvailableCompressionMethods(unsigned int & num) -> SbName"},
	 { "SoOutput_setBuffer", _wrap_SoOutput_setBuffer, METH_VARARGS, "SoOutput_setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc, int32_t offset=0)"},
	 { "SoOutput_getBuffer", _wrap_SoOutput_getBuffer, METH_VARARGS, "SoOutput_getBuffer(SoOutput self, void *& bufPointer, size_t & nBytes) -> SbBool"},
	 { "SoOutput_getBufferSize", _wrap_SoOutput_getBufferSize, METH_O, "SoOutput_getBufferSize(SoOutput self) -> size_t"},
	 { "SoOutput_resetBuffer", _wrap_SoOutput_resetBuffer, METH_O, "SoOutput_resetBuffer(SoOutput self)"},
	 { "SoOutput_setBinary", _wrap_SoOutput_setBinary, METH_VARARGS, "SoOutput_setBinary(SoOutput self, SbBool const flag)"},
	 { "SoOutput_isBinary", _wrap_SoOutput_isBinary, METH_O, "SoOutput_isBinary(SoOutput self) -> SbBool"},
	 { "SoOutput_setHeaderString", _wrap_SoOutput_setHeaderString, METH_VARARGS, "SoOutput_setHeaderString(SoOutput self, SbString str)"},
	 { "SoOutput_resetHeaderString", _wrap_SoOutput_resetHeaderString, METH_O, "SoOutput_resetHeaderString(SoOutput self)"},
	 { "SoOutput_setFloatPrecision", _wrap_SoOutput_setFloatPrecision, METH_VARARGS, "SoOutput_setFloatPrecision(SoOutput self, int const precision)"},
	 { "SoOutput_setStage", _wrap_SoOutput_setStage, METH_VARARGS, "SoOutput_setStage(SoOutput self, SoOutput::Stage stage)"},
	 { "SoOutput_getStage", _wrap_SoOutput_getStage, METH_O, "SoOutput_getStage(SoOutput self) -> SoOutput::Stage"},
	 { "SoOutput_incrementIndent", _wrap_SoOutput_incrementIndent, METH_VARARGS, "SoOutput_incrementIndent(SoOutput self, int const levels=1)"},
	 { "SoOutput_decrementIndent", _wrap_SoOutput_decrementIndent, METH_VARARGS, "SoOutput_decrementIndent(SoOutput self, int const levels=1)"},
	 { "SoOutput_write", _wrap_SoOutput_write, METH_VARARGS, "\n"
		"SoOutput_write(SoOutput self, char const c)\n"
		"SoOutput_write(SoOutput self, char const * s)\n"
		"SoOutput_write(SoOutput self, SbString s)\n"
		"SoOutput_write(SoOutput self, SbName n)\n"
		"SoOutput_write(SoOutput self, int const i)\n"
		"SoOutput_write(SoOutput self, unsigned int const i)\n"
		"SoOutput_write(SoOutput self, short const s)\n"
		"SoOutput_write(SoOutput self, unsigned short const s)\n"
		"SoOutput_write(SoOutput self, float const f)\n"
		"SoOutput_write(SoOutput self, double const d)\n"
		""},
	 { "SoOutput_writeBinaryArray", _wrap_SoOutput_writeBinaryArray, METH_VARARGS, "\n"
		"SoOutput_writeBinaryArray(SoOutput self, unsigned char const * c, int const length)\n"
		"SoOutput_writeBinaryArray(SoOutput self, int32_t const *const l, int const length)\n"
		"SoOutput_writeBinaryArray(SoOutput self, float const *const f, int const length)\n"
		"SoOutput_writeBinaryArray(SoOutput self, double const *const d, int const length)\n"
		""},
	 { "SoOutput_indent", _wrap_SoOutput_indent, METH_O, "SoOutput_indent(SoOutput self)"},
	 { "SoOutput_reset", _wrap_SoOutput_reset, METH_O, "SoOutput_reset(SoOutput self)"},
	 { "SoOutput_setCompact", _wrap_SoOutput_setCompact, METH_VARARGS, "SoOutput_setCompact(SoOutput self, SbBool flag)"},
	 { "SoOutput_isCompact", _wrap_SoOutput_isCompact, METH_O, "SoOutput_isCompact(SoOutput self) -> SbBool"},
	 { "SoOutput_setAnnotation", _wrap_SoOutput_setAnnotation, METH_VARARGS, "SoOutput_setAnnotation(SoOutput self, uint32_t bits)"},
	 { "SoOutput_getAnnotation", _wrap_SoOutput_getAnnotation, METH_O, "SoOutput_getAnnotation(SoOutput self) -> uint32_t"},
	 { "SoOutput_getDefaultASCIIHeader", _wrap_SoOutput_getDefaultASCIIHeader, METH_NOARGS, "SoOutput_getDefaultASCIIHeader() -> SbString"},
	 { "SoOutput_getDefaultBinaryHeader", _wrap_SoOutput_getDefaultBinaryHeader, METH_NOARGS, "SoOutput_getDefaultBinaryHeader() -> SbString"},
	 { "SoOutput_addReference", _wrap_SoOutput_addReference, METH_VARARGS, "SoOutput_addReference(SoOutput self, SoBase base) -> int"},
	 { "SoOutput_findReference", _wrap_SoOutput_findReference, METH_VARARGS, "SoOutput_findReference(SoOutput self, SoBase base) -> int"},
	 { "SoOutput_setReference", _wrap_SoOutput_setReference, METH_VARARGS, "SoOutput_setReference(SoOutput self, SoBase base, int refid)"},
	 { "SoOutput_addDEFNode", _wrap_SoOutput_addDEFNode, METH_VARARGS, "SoOutput_addDEFNode(SoOutput self, SbName name)"},
	 { "SoOutput_lookupDEFNode", _wrap_SoOutput_lookupDEFNode, METH_VARARGS, "SoOutput_lookupDEFNode(SoOutput self, SbName name) -> SbBool"},
	 { "SoOutput_removeDEFNode", _wrap_SoOutput_removeDEFNode, METH_VARARGS, "SoOutput_removeDEFNode(SoOutput self, SbName name)"},
	 { "SoOutput_pushProto", _wrap_SoOutput_pushProto, METH_VARARGS, "SoOutput_pushProto(SoOutput self, SoProto proto)"},
	 { "SoOutput_getCurrentProto", _wrap_SoOutput_getCurrentProto, METH_O, "SoOutput_getCurrentProto(SoOutput self) -> SoProto"},
	 { "SoOutput_popProto", _wrap_SoOutput_popProto, METH_O, "SoOutput_popProto(SoOutput self)"},
	 { "SoOutput_addRoute", _wrap_SoOutput_addRoute, METH_VARARGS, "SoOutput_addRoute(SoOutput self, SoFieldContainer srcFrom, SbName fromfield, SoFieldContainer destTo, SbName tofield)"},
	 { "SoOutput_resolveRoutes", _wrap_SoOutput_resolveRoutes, METH_O, "SoOutput_resolveRoutes(SoOutput self)"},
	 { "SoOutput_swigregister", SoOutput_swigregister, METH_O, NULL},
	 { "SoOutput_swiginit", SoOutput_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFEnum", _wrap_new_SoSFEnum, METH_NOARGS, "new_SoSFEnum() -> SoSFEnum"},
	 { "delete_SoSFEnum", _wrap_delete_SoSFEnum, METH_O, "delete_SoSFEnum(SoSFEnum self)"},
	 { "SoSFEnum_createInstance", _wrap_SoSFEnum_createInstance, METH_NOARGS, "SoSFEnum_createInstance() -> void *"},
	 { "SoSFEnum_getClassTypeId", _wrap_SoSFEnum_getClassTypeId, METH_NOARGS, "SoSFEnum_getClassTypeId() -> SoType"},
	 { "SoSFEnum_getTypeId", _wrap_SoSFEnum_getTypeId, METH_O, "SoSFEnum_getTypeId(SoSFEnum self) -> SoType"},
	 { "SoSFEnum_copyFrom", _wrap_SoSFEnum_copyFrom, METH_VARARGS, "SoSFEnum_copyFrom(SoSFEnum self, SoField field)"},
	 { "SoSFEnum_isSame", _wrap_SoSFEnum_isSame, METH_VARARGS, "SoSFEnum_isSame(SoSFEnum self, SoField field) -> SbBool"},
	 { "SoSFEnum_getValue", _wrap_SoSFEnum_getValue, METH_O, "SoSFEnum_getValue(SoSFEnum self) -> int"},
	 { "SoSFEnum___eq__", _wrap_SoSFEnum___eq__, METH_VARARGS, "SoSFEnum___eq__(SoSFEnum self, SoSFEnum field) -> int"},
	 { "SoSFEnum___ne__", _wrap_SoSFEnum___ne__, METH_VARARGS, "SoSFEnum___ne__(SoSFEnum self, SoSFEnum field) -> int"},
	 { "SoSFEnum_initClass", _wrap_SoSFEnum_initClass, METH_NOARGS, "SoSFEnum_initClass()"},
	 { "SoSFEnum_setEnums", _wrap_SoSFEnum_setEnums, METH_VARARGS, "SoSFEnum_setEnums(SoSFEnum self, int const num, int const * vals, SbName names)"},
	 { "SoSFEnum_getNumEnums", _wrap_SoSFEnum_getNumEnums, METH_O, "SoSFEnum_getNumEnums(SoSFEnum self) -> int"},
	 { "SoSFEnum_getEnum", _wrap_SoSFEnum_getEnum, METH_VARARGS, "SoSFEnum_getEnum(SoSFEnum self, int const idx, SbName name) -> int"},
	 { "SoSFEnum_setValue", _wrap_SoSFEnum_setValue, METH_VARARGS, "\n"
		"SoSFEnum_setValue(SoSFEnum self, int newvalue)\n"
		"SoSFEnum_setValue(SoSFEnum self, SbName name)\n"
		"SoSFEnum_setValue(SoSFEnum self, SoSFEnum other)\n"
		""},
	 { "SoSFEnum_swigregister", SoSFEnum_swigregister, METH_O, NULL},
	 { "SoSFEnum_swiginit", SoSFEnum_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFFloat", _wrap_new_SoSFFloat, METH_NOARGS, "new_SoSFFloat() -> SoSFFloat"},
	 { "delete_SoSFFloat", _wrap_delete_SoSFFloat, METH_O, "delete_SoSFFloat(SoSFFloat self)"},
	 { "SoSFFloat_createInstance", _wrap_SoSFFloat_createInstance, METH_NOARGS, "SoSFFloat_createInstance() -> void *"},
	 { "SoSFFloat_getClassTypeId", _wrap_SoSFFloat_getClassTypeId, METH_NOARGS, "SoSFFloat_getClassTypeId() -> SoType"},
	 { "SoSFFloat_getTypeId", _wrap_SoSFFloat_getTypeId, METH_O, "SoSFFloat_getTypeId(SoSFFloat self) -> SoType"},
	 { "SoSFFloat_copyFrom", _wrap_SoSFFloat_copyFrom, METH_VARARGS, "SoSFFloat_copyFrom(SoSFFloat self, SoField field)"},
	 { "SoSFFloat_isSame", _wrap_SoSFFloat_isSame, METH_VARARGS, "SoSFFloat_isSame(SoSFFloat self, SoField field) -> SbBool"},
	 { "SoSFFloat_getValue", _wrap_SoSFFloat_getValue, METH_O, "SoSFFloat_getValue(SoSFFloat self) -> float"},
	 { "SoSFFloat___eq__", _wrap_SoSFFloat___eq__, METH_VARARGS, "SoSFFloat___eq__(SoSFFloat self, SoSFFloat field) -> int"},
	 { "SoSFFloat___ne__", _wrap_SoSFFloat___ne__, METH_VARARGS, "SoSFFloat___ne__(SoSFFloat self, SoSFFloat field) -> int"},
	 { "SoSFFloat_initClass", _wrap_SoSFFloat_initClass, METH_NOARGS, "SoSFFloat_initClass()"},
	 { "SoSFFloat_setValue", _wrap_SoSFFloat_setValue, METH_VARARGS, "\n"
		"SoSFFloat_setValue(SoSFFloat self, float newvalue)\n"
		"SoSFFloat_setValue(SoSFFloat self, SoSFFloat other)\n"
		""},
	 { "SoSFFloat_swigregister", SoSFFloat_swigregister, METH_O, NULL},
	 { "SoSFFloat_swiginit", SoSFFloat_swiginit, METH_VARARGS, NULL},
	 { "SoComplexityTypeElement_getClassTypeId", _wrap_SoComplexityTypeElement_getClassTypeId, METH_NOARGS, "SoComplexityTypeElement_getClassTypeId() -> SoType"},
	 { "SoComplexityTypeElement_getClassStackIndex", _wrap_SoComplexityTypeElement_getClassStackIndex, METH_NOARGS, "SoComplexityTypeElement_getClassStackIndex() -> int"},
	 { "SoComplexityTypeElement_createInstance", _wrap_SoComplexityTypeElement_createInstance, METH_NOARGS, "SoComplexityTypeElement_createInstance() -> void *"},
	 { "SoComplexityTypeElement_initClass", _wrap_SoComplexityTypeElement_initClass, METH_NOARGS, "SoComplexityTypeElement_initClass()"},
	 { "SoComplexityTypeElement_init", _wrap_SoComplexityTypeElement_init, METH_VARARGS, "SoComplexityTypeElement_init(SoComplexityTypeElement self, SoState state)"},
	 { "SoComplexityTypeElement_set", _wrap_SoComplexityTypeElement_set, METH_VARARGS, "\n"
		"SoComplexityTypeElement_set(SoState state, SoNode node, SoComplexityTypeElement::Type const type)\n"
		"SoComplexityTypeElement_set(SoState state, SoComplexityTypeElement::Type const type)\n"
		""},
	 { "SoComplexityTypeElement_get", _wrap_SoComplexityTypeElement_get, METH_O, "SoComplexityTypeElement_get(SoState state) -> SoComplexityTypeElement::Type"},
	 { "SoComplexityTypeElement_getDefault", _wrap_SoComplexityTypeElement_getDefault, METH_NOARGS, "SoComplexityTypeElement_getDefault() -> SoComplexityTypeElement::Type"},
	 { "SoComplexityTypeElement_swigregister", SoComplexityTypeElement_swigregister, METH_O, NULL},
	 { "SoComplexity_getClassTypeId", _wrap_SoComplexity_getClassTypeId, METH_NOARGS, "SoComplexity_getClassTypeId() -> SoType"},
	 { "SoComplexity_getTypeId", _wrap_SoComplexity_getTypeId, METH_O, "SoComplexity_getTypeId(SoComplexity self) -> SoType"},
	 { "SoComplexity_initClass", _wrap_SoComplexity_initClass, METH_NOARGS, "SoComplexity_initClass()"},
	 { "new_SoComplexity", _wrap_new_SoComplexity, METH_NOARGS, "new_SoComplexity() -> SoComplexity"},
	 { "SoComplexity_type_set", _wrap_SoComplexity_type_set, METH_VARARGS, "SoComplexity_type_set(SoComplexity self, SoSFEnum type)"},
	 { "SoComplexity_type_get", _wrap_SoComplexity_type_get, METH_O, "SoComplexity_type_get(SoComplexity self) -> SoSFEnum"},
	 { "SoComplexity_value_set", _wrap_SoComplexity_value_set, METH_VARARGS, "SoComplexity_value_set(SoComplexity self, SoSFFloat value)"},
	 { "SoComplexity_value_get", _wrap_SoComplexity_value_get, METH_O, "SoComplexity_value_get(SoComplexity self) -> SoSFFloat"},
	 { "SoComplexity_textureQuality_set", _wrap_SoComplexity_textureQuality_set, METH_VARARGS, "SoComplexity_textureQuality_set(SoComplexity self, SoSFFloat textureQuality)"},
	 { "SoComplexity_textureQuality_get", _wrap_SoComplexity_textureQuality_get, METH_O, "SoComplexity_textureQuality_get(SoComplexity self) -> SoSFFloat"},
	 { "SoComplexity_doAction", _wrap_SoComplexity_doAction, METH_VARARGS, "SoComplexity_doAction(SoComplexity self, SoAction action)"},
	 { "SoComplexity_callback", _wrap_SoComplexity_callback, METH_VARARGS, "SoComplexity_callback(SoComplexity self, SoCallbackAction action)"},
	 { "SoComplexity_getBoundingBox", _wrap_SoComplexity_getBoundingBox, METH_VARARGS, "SoComplexity_getBoundingBox(SoComplexity self, SoGetBoundingBoxAction action)"},
	 { "SoComplexity_GLRender", _wrap_SoComplexity_GLRender, METH_VARARGS, "SoComplexity_GLRender(SoComplexity self, SoGLRenderAction action)"},
	 { "SoComplexity_pick", _wrap_SoComplexity_pick, METH_VARARGS, "SoComplexity_pick(SoComplexity self, SoPickAction action)"},
	 { "SoComplexity_getPrimitiveCount", _wrap_SoComplexity_getPrimitiveCount, METH_VARARGS, "SoComplexity_getPrimitiveCount(SoComplexity self, SoGetPrimitiveCountAction action)"},
	 { "SoComplexity_swigregister", SoComplexity_swigregister, METH_O, NULL},
	 { "SoComplexity_swiginit", SoComplexity_swiginit, METH_VARARGS, NULL},
	 { "SoDrawStyleElement_getClassTypeId", _wrap_SoDrawStyleElement_getClassTypeId, METH_NOARGS, "SoDrawStyleElement_getClassTypeId() -> SoType"},
	 { "SoDrawStyleElement_getClassStackIndex", _wrap_SoDrawStyleElement_getClassStackIndex, METH_NOARGS, "SoDrawStyleElement_getClassStackIndex() -> int"},
	 { "SoDrawStyleElement_createInstance", _wrap_SoDrawStyleElement_createInstance, METH_NOARGS, "SoDrawStyleElement_createInstance() -> void *"},
	 { "SoDrawStyleElement_initClass", _wrap_SoDrawStyleElement_initClass, METH_NOARGS, "SoDrawStyleElement_initClass()"},
	 { "SoDrawStyleElement_init", _wrap_SoDrawStyleElement_init, METH_VARARGS, "SoDrawStyleElement_init(SoDrawStyleElement self, SoState state)"},
	 { "SoDrawStyleElement_set", _wrap_SoDrawStyleElement_set, METH_VARARGS, "\n"
		"SoDrawStyleElement_set(SoState state, SoNode node, SoDrawStyleElement::Style const style)\n"
		"SoDrawStyleElement_set(SoState state, SoDrawStyleElement::Style const style)\n"
		""},
	 { "SoDrawStyleElement_get", _wrap_SoDrawStyleElement_get, METH_O, "SoDrawStyleElement_get(SoState state) -> SoDrawStyleElement::Style"},
	 { "SoDrawStyleElement_getDefault", _wrap_SoDrawStyleElement_getDefault, METH_NOARGS, "SoDrawStyleElement_getDefault() -> SoDrawStyleElement::Style"},
	 { "SoDrawStyleElement_swigregister", SoDrawStyleElement_swigregister, METH_O, NULL},
	 { "new_SoSFUShort", _wrap_new_SoSFUShort, METH_NOARGS, "new_SoSFUShort() -> SoSFUShort"},
	 { "delete_SoSFUShort", _wrap_delete_SoSFUShort, METH_O, "delete_SoSFUShort(SoSFUShort self)"},
	 { "SoSFUShort_createInstance", _wrap_SoSFUShort_createInstance, METH_NOARGS, "SoSFUShort_createInstance() -> void *"},
	 { "SoSFUShort_getClassTypeId", _wrap_SoSFUShort_getClassTypeId, METH_NOARGS, "SoSFUShort_getClassTypeId() -> SoType"},
	 { "SoSFUShort_getTypeId", _wrap_SoSFUShort_getTypeId, METH_O, "SoSFUShort_getTypeId(SoSFUShort self) -> SoType"},
	 { "SoSFUShort_copyFrom", _wrap_SoSFUShort_copyFrom, METH_VARARGS, "SoSFUShort_copyFrom(SoSFUShort self, SoField field)"},
	 { "SoSFUShort_isSame", _wrap_SoSFUShort_isSame, METH_VARARGS, "SoSFUShort_isSame(SoSFUShort self, SoField field) -> SbBool"},
	 { "SoSFUShort_getValue", _wrap_SoSFUShort_getValue, METH_O, "SoSFUShort_getValue(SoSFUShort self) -> unsigned short"},
	 { "SoSFUShort___eq__", _wrap_SoSFUShort___eq__, METH_VARARGS, "SoSFUShort___eq__(SoSFUShort self, SoSFUShort field) -> int"},
	 { "SoSFUShort___ne__", _wrap_SoSFUShort___ne__, METH_VARARGS, "SoSFUShort___ne__(SoSFUShort self, SoSFUShort field) -> int"},
	 { "SoSFUShort_initClass", _wrap_SoSFUShort_initClass, METH_NOARGS, "SoSFUShort_initClass()"},
	 { "SoSFUShort_setValue", _wrap_SoSFUShort_setValue, METH_VARARGS, "\n"
		"SoSFUShort_setValue(SoSFUShort self, unsigned short newvalue)\n"
		"SoSFUShort_setValue(SoSFUShort self, SoSFUShort other)\n"
		""},
	 { "SoSFUShort_swigregister", SoSFUShort_swigregister, METH_O, NULL},
	 { "SoSFUShort_swiginit", SoSFUShort_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFInt32", _wrap_new_SoSFInt32, METH_NOARGS, "new_SoSFInt32() -> SoSFInt32"},
	 { "delete_SoSFInt32", _wrap_delete_SoSFInt32, METH_O, "delete_SoSFInt32(SoSFInt32 self)"},
	 { "SoSFInt32_createInstance", _wrap_SoSFInt32_createInstance, METH_NOARGS, "SoSFInt32_createInstance() -> void *"},
	 { "SoSFInt32_getClassTypeId", _wrap_SoSFInt32_getClassTypeId, METH_NOARGS, "SoSFInt32_getClassTypeId() -> SoType"},
	 { "SoSFInt32_getTypeId", _wrap_SoSFInt32_getTypeId, METH_O, "SoSFInt32_getTypeId(SoSFInt32 self) -> SoType"},
	 { "SoSFInt32_copyFrom", _wrap_SoSFInt32_copyFrom, METH_VARARGS, "SoSFInt32_copyFrom(SoSFInt32 self, SoField field)"},
	 { "SoSFInt32_isSame", _wrap_SoSFInt32_isSame, METH_VARARGS, "SoSFInt32_isSame(SoSFInt32 self, SoField field) -> SbBool"},
	 { "SoSFInt32_getValue", _wrap_SoSFInt32_getValue, METH_O, "SoSFInt32_getValue(SoSFInt32 self) -> int32_t"},
	 { "SoSFInt32___eq__", _wrap_SoSFInt32___eq__, METH_VARARGS, "SoSFInt32___eq__(SoSFInt32 self, SoSFInt32 field) -> int"},
	 { "SoSFInt32___ne__", _wrap_SoSFInt32___ne__, METH_VARARGS, "SoSFInt32___ne__(SoSFInt32 self, SoSFInt32 field) -> int"},
	 { "SoSFInt32_initClass", _wrap_SoSFInt32_initClass, METH_NOARGS, "SoSFInt32_initClass()"},
	 { "SoSFInt32_setValue", _wrap_SoSFInt32_setValue, METH_VARARGS, "\n"
		"SoSFInt32_setValue(SoSFInt32 self, int32_t newvalue)\n"
		"SoSFInt32_setValue(SoSFInt32 self, SoSFInt32 other)\n"
		""},
	 { "SoSFInt32_swigregister", SoSFInt32_swigregister, METH_O, NULL},
	 { "SoSFInt32_swiginit", SoSFInt32_swiginit, METH_VARARGS, NULL},
	 { "SoDrawStyle_getClassTypeId", _wrap_SoDrawStyle_getClassTypeId, METH_NOARGS, "SoDrawStyle_getClassTypeId() -> SoType"},
	 { "SoDrawStyle_getTypeId", _wrap_SoDrawStyle_getTypeId, METH_O, "SoDrawStyle_getTypeId(SoDrawStyle self) -> SoType"},
	 { "SoDrawStyle_initClass", _wrap_SoDrawStyle_initClass, METH_NOARGS, "SoDrawStyle_initClass()"},
	 { "new_SoDrawStyle", _wrap_new_SoDrawStyle, METH_NOARGS, "new_SoDrawStyle() -> SoDrawStyle"},
	 { "SoDrawStyle_style_set", _wrap_SoDrawStyle_style_set, METH_VARARGS, "SoDrawStyle_style_set(SoDrawStyle self, SoSFEnum style)"},
	 { "SoDrawStyle_style_get", _wrap_SoDrawStyle_style_get, METH_O, "SoDrawStyle_style_get(SoDrawStyle self) -> SoSFEnum"},
	 { "SoDrawStyle_pointSize_set", _wrap_SoDrawStyle_pointSize_set, METH_VARARGS, "SoDrawStyle_pointSize_set(SoDrawStyle self, SoSFFloat pointSize)"},
	 { "SoDrawStyle_pointSize_get", _wrap_SoDrawStyle_pointSize_get, METH_O, "SoDrawStyle_pointSize_get(SoDrawStyle self) -> SoSFFloat"},
	 { "SoDrawStyle_lineWidth_set", _wrap_SoDrawStyle_lineWidth_set, METH_VARARGS, "SoDrawStyle_lineWidth_set(SoDrawStyle self, SoSFFloat lineWidth)"},
	 { "SoDrawStyle_lineWidth_get", _wrap_SoDrawStyle_lineWidth_get, METH_O, "SoDrawStyle_lineWidth_get(SoDrawStyle self) -> SoSFFloat"},
	 { "SoDrawStyle_linePattern_set", _wrap_SoDrawStyle_linePattern_set, METH_VARARGS, "SoDrawStyle_linePattern_set(SoDrawStyle self, SoSFUShort linePattern)"},
	 { "SoDrawStyle_linePattern_get", _wrap_SoDrawStyle_linePattern_get, METH_O, "SoDrawStyle_linePattern_get(SoDrawStyle self) -> SoSFUShort"},
	 { "SoDrawStyle_linePatternScaleFactor_set", _wrap_SoDrawStyle_linePatternScaleFactor_set, METH_VARARGS, "SoDrawStyle_linePatternScaleFactor_set(SoDrawStyle self, SoSFInt32 linePatternScaleFactor)"},
	 { "SoDrawStyle_linePatternScaleFactor_get", _wrap_SoDrawStyle_linePatternScaleFactor_get, METH_O, "SoDrawStyle_linePatternScaleFactor_get(SoDrawStyle self) -> SoSFInt32"},
	 { "SoDrawStyle_doAction", _wrap_SoDrawStyle_doAction, METH_VARARGS, "SoDrawStyle_doAction(SoDrawStyle self, SoAction action)"},
	 { "SoDrawStyle_GLRender", _wrap_SoDrawStyle_GLRender, METH_VARARGS, "SoDrawStyle_GLRender(SoDrawStyle self, SoGLRenderAction action)"},
	 { "SoDrawStyle_callback", _wrap_SoDrawStyle_callback, METH_VARARGS, "SoDrawStyle_callback(SoDrawStyle self, SoCallbackAction action)"},
	 { "SoDrawStyle_swigregister", SoDrawStyle_swigregister, METH_O, NULL},
	 { "SoDrawStyle_swiginit", SoDrawStyle_swiginit, METH_VARARGS, NULL},
	 { "new_SbByteBuffer", _wrap_new_SbByteBuffer, METH_VARARGS, "\n"
		"SbByteBuffer(char const * buffer)\n"
		"SbByteBuffer(SbByteBuffer buffer)\n"
		"SbByteBuffer(size_t size=0, char const * buffer=None)\n"
		"new_SbByteBuffer(size_t size, unsigned char const * buffer) -> SbByteBuffer\n"
		""},
	 { "delete_SbByteBuffer", _wrap_delete_SbByteBuffer, METH_O, "delete_SbByteBuffer(SbByteBuffer self)"},
	 { "SbByteBuffer_isValid", _wrap_SbByteBuffer_isValid, METH_O, "SbByteBuffer_isValid(SbByteBuffer self) -> SbBool"},
	 { "SbByteBuffer_size", _wrap_SbByteBuffer_size, METH_O, "SbByteBuffer_size(SbByteBuffer self) -> size_t"},
	 { "SbByteBuffer_empty", _wrap_SbByteBuffer_empty, METH_O, "SbByteBuffer_empty(SbByteBuffer self) -> SbBool"},
	 { "SbByteBuffer___eq__", _wrap_SbByteBuffer___eq__, METH_VARARGS, "SbByteBuffer___eq__(SbByteBuffer self, SbByteBuffer that) -> SbBool"},
	 { "SbByteBuffer___iadd__", _wrap_SbByteBuffer___iadd__, METH_VARARGS, "SbByteBuffer___iadd__(SbByteBuffer self, SbByteBuffer buf) -> SbByteBuffer"},
	 { "SbByteBuffer_push", _wrap_SbByteBuffer_push, METH_VARARGS, "SbByteBuffer_push(SbByteBuffer self, SbByteBuffer buf)"},
	 { "SbByteBuffer_constData", _wrap_SbByteBuffer_constData, METH_O, "SbByteBuffer_constData(SbByteBuffer self) -> char const *"},
	 { "SbByteBuffer_data", _wrap_SbByteBuffer_data, METH_O, "SbByteBuffer_data(SbByteBuffer self) -> char *"},
	 { "SbByteBuffer_invalidBuffer", _wrap_SbByteBuffer_invalidBuffer, METH_NOARGS, "SbByteBuffer_invalidBuffer() -> SbByteBuffer"},
	 { "SbByteBuffer_makeUnique", _wrap_SbByteBuffer_makeUnique, METH_O, "SbByteBuffer_makeUnique(SbByteBuffer self)"},
	 { "SbByteBuffer_swigregister", SbByteBuffer_swigregister, METH_O, NULL},
	 { "SbByteBuffer_swiginit", SbByteBuffer_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec3f", _wrap_new_SbVec3f, METH_VARARGS, "\n"
		"SbVec3f()\n"
		"SbVec3f(float const [3] v)\n"
		"SbVec3f(float x, float y, float z)\n"
		"SbVec3f(SbVec3d v)\n"
		"SbVec3f(SbVec3b v)\n"
		"SbVec3f(SbVec3s v)\n"
		"SbVec3f(SbVec3i32 v)\n"
		"new_SbVec3f(SbPlane p0, SbPlane p1, SbPlane p2) -> SbVec3f\n"
		""},
	 { "SbVec3f_setValue", _wrap_SbVec3f_setValue, METH_VARARGS, "\n"
		"SbVec3f_setValue(SbVec3f self, float const [3] v) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, float x, float y, float z) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, SbVec3f barycentric, SbVec3f v0, SbVec3f v1, SbVec3f v2) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, SbVec3d v) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, SbVec3b v) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, SbVec3s v) -> SbVec3f\n"
		"SbVec3f_setValue(SbVec3f self, SbVec3i32 v) -> SbVec3f\n"
		""},
	 { "SbVec3f_getValue", _wrap_SbVec3f_getValue, METH_O, "SbVec3f_getValue(SbVec3f self) -> float const *"},
	 { "SbVec3f_equals", _wrap_SbVec3f_equals, METH_VARARGS, "SbVec3f_equals(SbVec3f self, SbVec3f v, float tolerance) -> SbBool"},
	 { "SbVec3f_cross", _wrap_SbVec3f_cross, METH_VARARGS, "SbVec3f_cross(SbVec3f self, SbVec3f v) -> SbVec3f"},
	 { "SbVec3f_dot", _wrap_SbVec3f_dot, METH_VARARGS, "SbVec3f_dot(SbVec3f self, SbVec3f v) -> float"},
	 { "SbVec3f_getClosestAxis", _wrap_SbVec3f_getClosestAxis, METH_O, "SbVec3f_getClosestAxis(SbVec3f self) -> SbVec3f"},
	 { "SbVec3f_length", _wrap_SbVec3f_length, METH_O, "SbVec3f_length(SbVec3f self) -> float"},
	 { "SbVec3f_sqrLength", _wrap_SbVec3f_sqrLength, METH_O, "SbVec3f_sqrLength(SbVec3f self) -> float"},
	 { "SbVec3f_normalize", _wrap_SbVec3f_normalize, METH_O, "SbVec3f_normalize(SbVec3f self) -> float"},
	 { "SbVec3f_negate", _wrap_SbVec3f_negate, METH_O, "SbVec3f_negate(SbVec3f self)"},
	 { "SbVec3f___imul__", _wrap_SbVec3f___imul__, METH_VARARGS, "SbVec3f___imul__(SbVec3f self, float d) -> SbVec3f"},
	 { "SbVec3f___itruediv__", _wrap_SbVec3f___itruediv__, METH_VARARGS, "SbVec3f___itruediv__(SbVec3f self, float d) -> SbVec3f"},
	 { "SbVec3f___iadd__", _wrap_SbVec3f___iadd__, METH_VARARGS, "SbVec3f___iadd__(SbVec3f self, SbVec3f v) -> SbVec3f"},
	 { "SbVec3f___isub__", _wrap_SbVec3f___isub__, METH_VARARGS, "SbVec3f___isub__(SbVec3f self, SbVec3f v) -> SbVec3f"},
	 { "SbVec3f___neg__", _wrap_SbVec3f___neg__, METH_O, "SbVec3f___neg__(SbVec3f self) -> SbVec3f"},
	 { "SbVec3f_toString", _wrap_SbVec3f_toString, METH_O, "SbVec3f_toString(SbVec3f self) -> SbString"},
	 { "SbVec3f_fromString", _wrap_SbVec3f_fromString, METH_VARARGS, "SbVec3f_fromString(SbVec3f self, SbString str) -> SbBool"},
	 { "SbVec3f_output", _wrap_SbVec3f_output, METH_VARARGS, "SbVec3f_output(SbVec3f self, FILE * fp)"},
	 { "SbVec3f___add__", _wrap_SbVec3f___add__, METH_VARARGS, "SbVec3f___add__(SbVec3f self, SbVec3f u) -> SbVec3f"},
	 { "SbVec3f___sub__", _wrap_SbVec3f___sub__, METH_VARARGS, "SbVec3f___sub__(SbVec3f self, SbVec3f u) -> SbVec3f"},
	 { "SbVec3f___mul__", _wrap_SbVec3f___mul__, METH_VARARGS, "\n"
		"SbVec3f___mul__(SbVec3f self, float const d) -> SbVec3f\n"
		"SbVec3f___mul__(SbVec3f self, SbMatrix m) -> SbVec3f\n"
		""},
	 { "SbVec3f___rmul__", _wrap_SbVec3f___rmul__, METH_VARARGS, "SbVec3f___rmul__(SbVec3f self, float const d) -> SbVec3f"},
	 { "SbVec3f___div__", _wrap_SbVec3f___div__, METH_VARARGS, "SbVec3f___div__(SbVec3f self, float const d) -> SbVec3f"},
	 { "SbVec3f___truediv__", _wrap_SbVec3f___truediv__, METH_VARARGS, "SbVec3f___truediv__(SbVec3f self, float const d) -> SbVec3f"},
	 { "SbVec3f___eq__", _wrap_SbVec3f___eq__, METH_VARARGS, "SbVec3f___eq__(SbVec3f self, SbVec3f u) -> int"},
	 { "SbVec3f___nq__", _wrap_SbVec3f___nq__, METH_VARARGS, "SbVec3f___nq__(SbVec3f self, SbVec3f u) -> int"},
	 { "SbVec3f___getitem__", _wrap_SbVec3f___getitem__, METH_VARARGS, "SbVec3f___getitem__(SbVec3f self, int i) -> float"},
	 { "SbVec3f___setitem__", _wrap_SbVec3f___setitem__, METH_VARARGS, "SbVec3f___setitem__(SbVec3f self, int i, float value)"},
	 { "delete_SbVec3f", _wrap_delete_SbVec3f, METH_O, "delete_SbVec3f(SbVec3f self)"},
	 { "SbVec3f_swigregister", SbVec3f_swigregister, METH_O, NULL},
	 { "SbVec3f_swiginit", SbVec3f_swiginit, METH_VARARGS, NULL},
	 { "new_SbColor", _wrap_new_SbColor, METH_VARARGS, "\n"
		"SbColor()\n"
		"SbColor(SbVec3f v)\n"
		"SbColor(float const *const rgb)\n"
		"new_SbColor(float const r, float const g, float const b) -> SbColor\n"
		""},
	 { "SbColor_setHSVValue", _wrap_SbColor_setHSVValue, METH_VARARGS, "\n"
		"SbColor_setHSVValue(SbColor self, float h, float s, float v) -> SbColor\n"
		"SbColor_setHSVValue(SbColor self, float const [3] hsv) -> SbColor\n"
		""},
	 { "SbColor_getHSVValue", _wrap_SbColor_getHSVValue, METH_O, "SbColor_getHSVValue(SbColor self)"},
	 { "SbColor_setPackedValue", _wrap_SbColor_setPackedValue, METH_VARARGS, "SbColor_setPackedValue(SbColor self, uint32_t const rgba, float & transparency) -> SbColor"},
	 { "SbColor_getPackedValue", _wrap_SbColor_getPackedValue, METH_VARARGS, "SbColor_getPackedValue(SbColor self, float const transparency=0.0) -> uint32_t"},
	 { "SbColor___add__", _wrap_SbColor___add__, METH_VARARGS, "SbColor___add__(SbColor self, SbColor u) -> SbColor"},
	 { "SbColor___sub__", _wrap_SbColor___sub__, METH_VARARGS, "SbColor___sub__(SbColor self, SbColor u) -> SbColor"},
	 { "SbColor___mul__", _wrap_SbColor___mul__, METH_VARARGS, "SbColor___mul__(SbColor self, float const d) -> SbColor"},
	 { "SbColor___rmul__", _wrap_SbColor___rmul__, METH_VARARGS, "SbColor___rmul__(SbColor self, float const d) -> SbColor"},
	 { "SbColor___div__", _wrap_SbColor___div__, METH_VARARGS, "SbColor___div__(SbColor self, float const d) -> SbColor"},
	 { "SbColor___eq__", _wrap_SbColor___eq__, METH_VARARGS, "SbColor___eq__(SbColor self, SbColor u) -> int"},
	 { "SbColor___nq__", _wrap_SbColor___nq__, METH_VARARGS, "SbColor___nq__(SbColor self, SbColor u) -> int"},
	 { "SbColor___getitem__", _wrap_SbColor___getitem__, METH_VARARGS, "SbColor___getitem__(SbColor self, int i) -> float"},
	 { "SbColor___setitem__", _wrap_SbColor___setitem__, METH_VARARGS, "SbColor___setitem__(SbColor self, int i, float value)"},
	 { "delete_SbColor", _wrap_delete_SbColor, METH_O, "delete_SbColor(SbColor self)"},
	 { "SbColor_swigregister", SbColor_swigregister, METH_O, NULL},
	 { "SbColor_swiginit", SbColor_swiginit, METH_VARARGS, NULL},
	 { "SoLazyElement_getClassTypeId", _wrap_SoLazyElement_getClassTypeId, METH_NOARGS, "SoLazyElement_getClassTypeId() -> SoType"},
	 { "SoLazyElement_getClassStackIndex", _wrap_SoLazyElement_getClassStackIndex, METH_NOARGS, "SoLazyElement_getClassStackIndex() -> int"},
	 { "SoLazyElement_createInstance", _wrap_SoLazyElement_createInstance, METH_NOARGS, "SoLazyElement_createInstance() -> void *"},
	 { "SoLazyElement_initClass", _wrap_SoLazyElement_initClass, METH_NOARGS, "SoLazyElement_initClass()"},
	 { "SoLazyElement_init", _wrap_SoLazyElement_init, METH_VARARGS, "SoLazyElement_init(SoLazyElement self, SoState state)"},
	 { "SoLazyElement_push", _wrap_SoLazyElement_push, METH_VARARGS, "SoLazyElement_push(SoLazyElement self, SoState state)"},
	 { "SoLazyElement_matches", _wrap_SoLazyElement_matches, METH_VARARGS, "SoLazyElement_matches(SoLazyElement self, SoElement arg2) -> SbBool"},
	 { "SoLazyElement_copyMatchInfo", _wrap_SoLazyElement_copyMatchInfo, METH_O, "SoLazyElement_copyMatchInfo(SoLazyElement self) -> SoElement"},
	 { "SoLazyElement_setToDefault", _wrap_SoLazyElement_setToDefault, METH_O, "SoLazyElement_setToDefault(SoState state)"},
	 { "SoLazyElement_setDiffuse", _wrap_SoLazyElement_setDiffuse, METH_VARARGS, "SoLazyElement_setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"},
	 { "SoLazyElement_setTransparency", _wrap_SoLazyElement_setTransparency, METH_VARARGS, "SoLazyElement_setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"},
	 { "SoLazyElement_setColorIndices", _wrap_SoLazyElement_setColorIndices, METH_VARARGS, "SoLazyElement_setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"},
	 { "SoLazyElement_setAmbient", _wrap_SoLazyElement_setAmbient, METH_VARARGS, "SoLazyElement_setAmbient(SoState state, SbColor color)"},
	 { "SoLazyElement_setEmissive", _wrap_SoLazyElement_setEmissive, METH_VARARGS, "SoLazyElement_setEmissive(SoState state, SbColor color)"},
	 { "SoLazyElement_setSpecular", _wrap_SoLazyElement_setSpecular, METH_VARARGS, "SoLazyElement_setSpecular(SoState state, SbColor color)"},
	 { "SoLazyElement_setShininess", _wrap_SoLazyElement_setShininess, METH_VARARGS, "SoLazyElement_setShininess(SoState state, float value)"},
	 { "SoLazyElement_setColorMaterial", _wrap_SoLazyElement_setColorMaterial, METH_VARARGS, "SoLazyElement_setColorMaterial(SoState state, SbBool value)"},
	 { "SoLazyElement_enableBlending", _wrap_SoLazyElement_enableBlending, METH_VARARGS, "SoLazyElement_enableBlending(SoState state, int sfactor, int dfactor)"},
	 { "SoLazyElement_enableSeparateBlending", _wrap_SoLazyElement_enableSeparateBlending, METH_VARARGS, "SoLazyElement_enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"},
	 { "SoLazyElement_disableBlending", _wrap_SoLazyElement_disableBlending, METH_O, "SoLazyElement_disableBlending(SoState state)"},
	 { "SoLazyElement_setLightModel", _wrap_SoLazyElement_setLightModel, METH_VARARGS, "SoLazyElement_setLightModel(SoState state, int32_t const model)"},
	 { "SoLazyElement_setVertexOrdering", _wrap_SoLazyElement_setVertexOrdering, METH_VARARGS, "SoLazyElement_setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"},
	 { "SoLazyElement_setBackfaceCulling", _wrap_SoLazyElement_setBackfaceCulling, METH_VARARGS, "SoLazyElement_setBackfaceCulling(SoState state, SbBool onoff)"},
	 { "SoLazyElement_setTwosideLighting", _wrap_SoLazyElement_setTwosideLighting, METH_VARARGS, "SoLazyElement_setTwosideLighting(SoState state, SbBool onoff)"},
	 { "SoLazyElement_setShadeModel", _wrap_SoLazyElement_setShadeModel, METH_VARARGS, "SoLazyElement_setShadeModel(SoState state, SbBool flatshading)"},
	 { "SoLazyElement_setAlphaTest", _wrap_SoLazyElement_setAlphaTest, METH_VARARGS, "SoLazyElement_setAlphaTest(SoState state, int func, float value)"},
	 { "SoLazyElement_getDiffuse", _wrap_SoLazyElement_getDiffuse, METH_VARARGS, "SoLazyElement_getDiffuse(SoState state, int index) -> SbColor"},
	 { "SoLazyElement_getTransparency", _wrap_SoLazyElement_getTransparency, METH_VARARGS, "SoLazyElement_getTransparency(SoState arg1, int index) -> float"},
	 { "SoLazyElement_getPackedColors", _wrap_SoLazyElement_getPackedColors, METH_O, "SoLazyElement_getPackedColors(SoState arg1) -> uint32_t const *"},
	 { "SoLazyElement_getColorIndices", _wrap_SoLazyElement_getColorIndices, METH_O, "SoLazyElement_getColorIndices(SoState arg1) -> int32_t const *"},
	 { "SoLazyElement_getColorIndex", _wrap_SoLazyElement_getColorIndex, METH_VARARGS, "SoLazyElement_getColorIndex(SoState arg1, int num) -> int32_t"},
	 { "SoLazyElement_getAmbient", _wrap_SoLazyElement_getAmbient, METH_O, "SoLazyElement_getAmbient(SoState arg1) -> SbColor"},
	 { "SoLazyElement_getEmissive", _wrap_SoLazyElement_getEmissive, METH_O, "SoLazyElement_getEmissive(SoState arg1) -> SbColor"},
	 { "SoLazyElement_getSpecular", _wrap_SoLazyElement_getSpecular, METH_O, "SoLazyElement_getSpecular(SoState arg1) -> SbColor"},
	 { "SoLazyElement_getShininess", _wrap_SoLazyElement_getShininess, METH_O, "SoLazyElement_getShininess(SoState arg1) -> float"},
	 { "SoLazyElement_getColorMaterial", _wrap_SoLazyElement_getColorMaterial, METH_O, "SoLazyElement_getColorMaterial(SoState arg1) -> SbBool"},
	 { "SoLazyElement_getBlending", _wrap_SoLazyElement_getBlending, METH_VARARGS, "SoLazyElement_getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"},
	 { "SoLazyElement_getAlphaBlending", _wrap_SoLazyElement_getAlphaBlending, METH_VARARGS, "SoLazyElement_getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"},
	 { "SoLazyElement_getLightModel", _wrap_SoLazyElement_getLightModel, METH_O, "SoLazyElement_getLightModel(SoState arg1) -> int32_t"},
	 { "SoLazyElement_getAlphaTest", _wrap_SoLazyElement_getAlphaTest, METH_VARARGS, "SoLazyElement_getAlphaTest(SoState state, float & value) -> int"},
	 { "SoLazyElement_getTwoSidedLighting", _wrap_SoLazyElement_getTwoSidedLighting, METH_O, "SoLazyElement_getTwoSidedLighting(SoState state) -> SbBool"},
	 { "SoLazyElement_getNumDiffuse", _wrap_SoLazyElement_getNumDiffuse, METH_O, "SoLazyElement_getNumDiffuse(SoLazyElement self) -> int32_t"},
	 { "SoLazyElement_getNumTransparencies", _wrap_SoLazyElement_getNumTransparencies, METH_O, "SoLazyElement_getNumTransparencies(SoLazyElement self) -> int32_t"},
	 { "SoLazyElement_getNumColorIndices", _wrap_SoLazyElement_getNumColorIndices, METH_O, "SoLazyElement_getNumColorIndices(SoLazyElement self) -> int32_t"},
	 { "SoLazyElement_isPacked", _wrap_SoLazyElement_isPacked, METH_O, "SoLazyElement_isPacked(SoLazyElement self) -> SbBool"},
	 { "SoLazyElement_isTransparent", _wrap_SoLazyElement_isTransparent, METH_O, "SoLazyElement_isTransparent(SoLazyElement self) -> SbBool"},
	 { "SoLazyElement_getInstance", _wrap_SoLazyElement_getInstance, METH_O, "SoLazyElement_getInstance(SoState state) -> SoLazyElement"},
	 { "SoLazyElement_getDefaultAmbientIntensity", _wrap_SoLazyElement_getDefaultAmbientIntensity, METH_NOARGS, "SoLazyElement_getDefaultAmbientIntensity() -> float"},
	 { "SoLazyElement_getDefaultDiffuse", _wrap_SoLazyElement_getDefaultDiffuse, METH_NOARGS, "SoLazyElement_getDefaultDiffuse() -> SbColor"},
	 { "SoLazyElement_getDefaultAmbient", _wrap_SoLazyElement_getDefaultAmbient, METH_NOARGS, "SoLazyElement_getDefaultAmbient() -> SbColor"},
	 { "SoLazyElement_getDefaultSpecular", _wrap_SoLazyElement_getDefaultSpecular, METH_NOARGS, "SoLazyElement_getDefaultSpecular() -> SbColor"},
	 { "SoLazyElement_getDefaultEmissive", _wrap_SoLazyElement_getDefaultEmissive, METH_NOARGS, "SoLazyElement_getDefaultEmissive() -> SbColor"},
	 { "SoLazyElement_getDefaultShininess", _wrap_SoLazyElement_getDefaultShininess, METH_NOARGS, "SoLazyElement_getDefaultShininess() -> float"},
	 { "SoLazyElement_getDefaultPacked", _wrap_SoLazyElement_getDefaultPacked, METH_NOARGS, "SoLazyElement_getDefaultPacked() -> uint32_t"},
	 { "SoLazyElement_getDefaultTransparency", _wrap_SoLazyElement_getDefaultTransparency, METH_NOARGS, "SoLazyElement_getDefaultTransparency() -> float"},
	 { "SoLazyElement_getDefaultLightModel", _wrap_SoLazyElement_getDefaultLightModel, METH_NOARGS, "SoLazyElement_getDefaultLightModel() -> int32_t"},
	 { "SoLazyElement_getDefaultColorIndex", _wrap_SoLazyElement_getDefaultColorIndex, METH_NOARGS, "SoLazyElement_getDefaultColorIndex() -> int32_t"},
	 { "SoLazyElement_setMaterials", _wrap_SoLazyElement_setMaterials, METH_VARARGS, "SoLazyElement_setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"},
	 { "SoLazyElement_getWInstance", _wrap_SoLazyElement_getWInstance, METH_O, "SoLazyElement_getWInstance(SoState state) -> SoLazyElement"},
	 { "SoLazyElement_getPackedPointer", _wrap_SoLazyElement_getPackedPointer, METH_O, "SoLazyElement_getPackedPointer(SoLazyElement self) -> uint32_t const *"},
	 { "SoLazyElement_getDiffusePointer", _wrap_SoLazyElement_getDiffusePointer, METH_O, "SoLazyElement_getDiffusePointer(SoLazyElement self) -> SbColor"},
	 { "SoLazyElement_getColorIndexPointer", _wrap_SoLazyElement_getColorIndexPointer, METH_O, "SoLazyElement_getColorIndexPointer(SoLazyElement self) -> int32_t const *"},
	 { "SoLazyElement_getTransparencyPointer", _wrap_SoLazyElement_getTransparencyPointer, METH_O, "SoLazyElement_getTransparencyPointer(SoLazyElement self) -> float const *"},
	 { "SoLazyElement_setTransparencyType", _wrap_SoLazyElement_setTransparencyType, METH_VARARGS, "SoLazyElement_setTransparencyType(SoState state, int32_t type)"},
	 { "SoLazyElement_swigregister", SoLazyElement_swigregister, METH_O, NULL},
	 { "new_SoColorPacker", _wrap_new_SoColorPacker, METH_NOARGS, "new_SoColorPacker() -> SoColorPacker"},
	 { "delete_SoColorPacker", _wrap_delete_SoColorPacker, METH_O, "delete_SoColorPacker(SoColorPacker self)"},
	 { "SoColorPacker_getPackedColors", _wrap_SoColorPacker_getPackedColors, METH_O, "SoColorPacker_getPackedColors(SoColorPacker self) -> uint32_t *"},
	 { "SoColorPacker_diffuseMatch", _wrap_SoColorPacker_diffuseMatch, METH_VARARGS, "SoColorPacker_diffuseMatch(SoColorPacker self, SbUniqueId const nodeid) -> SbBool"},
	 { "SoColorPacker_transpMatch", _wrap_SoColorPacker_transpMatch, METH_VARARGS, "SoColorPacker_transpMatch(SoColorPacker self, SbUniqueId const nodeid) -> SbBool"},
	 { "SoColorPacker_setNodeIds", _wrap_SoColorPacker_setNodeIds, METH_VARARGS, "SoColorPacker_setNodeIds(SoColorPacker self, SbUniqueId const diffuse, SbUniqueId const transp)"},
	 { "SoColorPacker_getSize", _wrap_SoColorPacker_getSize, METH_O, "SoColorPacker_getSize(SoColorPacker self) -> int32_t"},
	 { "SoColorPacker_reallocate", _wrap_SoColorPacker_reallocate, METH_VARARGS, "SoColorPacker_reallocate(SoColorPacker self, int32_t const size)"},
	 { "SoColorPacker_getDiffuseId", _wrap_SoColorPacker_getDiffuseId, METH_O, "SoColorPacker_getDiffuseId(SoColorPacker self) -> SbUniqueId"},
	 { "SoColorPacker_getTranspId", _wrap_SoColorPacker_getTranspId, METH_O, "SoColorPacker_getTranspId(SoColorPacker self) -> SbUniqueId"},
	 { "SoColorPacker_swigregister", SoColorPacker_swigregister, METH_O, NULL},
	 { "SoColorPacker_swiginit", SoColorPacker_swiginit, METH_VARARGS, NULL},
	 { "SoLightModel_getClassTypeId", _wrap_SoLightModel_getClassTypeId, METH_NOARGS, "SoLightModel_getClassTypeId() -> SoType"},
	 { "SoLightModel_getTypeId", _wrap_SoLightModel_getTypeId, METH_O, "SoLightModel_getTypeId(SoLightModel self) -> SoType"},
	 { "SoLightModel_initClass", _wrap_SoLightModel_initClass, METH_NOARGS, "SoLightModel_initClass()"},
	 { "new_SoLightModel", _wrap_new_SoLightModel, METH_NOARGS, "new_SoLightModel() -> SoLightModel"},
	 { "SoLightModel_model_set", _wrap_SoLightModel_model_set, METH_VARARGS, "SoLightModel_model_set(SoLightModel self, SoSFEnum model)"},
	 { "SoLightModel_model_get", _wrap_SoLightModel_model_get, METH_O, "SoLightModel_model_get(SoLightModel self) -> SoSFEnum"},
	 { "SoLightModel_doAction", _wrap_SoLightModel_doAction, METH_VARARGS, "SoLightModel_doAction(SoLightModel self, SoAction action)"},
	 { "SoLightModel_GLRender", _wrap_SoLightModel_GLRender, METH_VARARGS, "SoLightModel_GLRender(SoLightModel self, SoGLRenderAction action)"},
	 { "SoLightModel_callback", _wrap_SoLightModel_callback, METH_VARARGS, "SoLightModel_callback(SoLightModel self, SoCallbackAction action)"},
	 { "SoLightModel_swigregister", SoLightModel_swigregister, METH_O, NULL},
	 { "SoLightModel_swiginit", SoLightModel_swiginit, METH_VARARGS, NULL},
	 { "SoMaterialBindingElement_getClassTypeId", _wrap_SoMaterialBindingElement_getClassTypeId, METH_NOARGS, "SoMaterialBindingElement_getClassTypeId() -> SoType"},
	 { "SoMaterialBindingElement_getClassStackIndex", _wrap_SoMaterialBindingElement_getClassStackIndex, METH_NOARGS, "SoMaterialBindingElement_getClassStackIndex() -> int"},
	 { "SoMaterialBindingElement_createInstance", _wrap_SoMaterialBindingElement_createInstance, METH_NOARGS, "SoMaterialBindingElement_createInstance() -> void *"},
	 { "SoMaterialBindingElement_initClass", _wrap_SoMaterialBindingElement_initClass, METH_NOARGS, "SoMaterialBindingElement_initClass()"},
	 { "SoMaterialBindingElement_init", _wrap_SoMaterialBindingElement_init, METH_VARARGS, "SoMaterialBindingElement_init(SoMaterialBindingElement self, SoState state)"},
	 { "SoMaterialBindingElement_set", _wrap_SoMaterialBindingElement_set, METH_VARARGS, "\n"
		"SoMaterialBindingElement_set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)\n"
		"SoMaterialBindingElement_set(SoState state, SoMaterialBindingElement::Binding const binding)\n"
		""},
	 { "SoMaterialBindingElement_get", _wrap_SoMaterialBindingElement_get, METH_O, "SoMaterialBindingElement_get(SoState state) -> SoMaterialBindingElement::Binding"},
	 { "SoMaterialBindingElement_getDefault", _wrap_SoMaterialBindingElement_getDefault, METH_NOARGS, "SoMaterialBindingElement_getDefault() -> SoMaterialBindingElement::Binding"},
	 { "SoMaterialBindingElement_swigregister", SoMaterialBindingElement_swigregister, METH_O, NULL},
	 { "SoMaterialBinding_getClassTypeId", _wrap_SoMaterialBinding_getClassTypeId, METH_NOARGS, "SoMaterialBinding_getClassTypeId() -> SoType"},
	 { "SoMaterialBinding_getTypeId", _wrap_SoMaterialBinding_getTypeId, METH_O, "SoMaterialBinding_getTypeId(SoMaterialBinding self) -> SoType"},
	 { "SoMaterialBinding_initClass", _wrap_SoMaterialBinding_initClass, METH_NOARGS, "SoMaterialBinding_initClass()"},
	 { "new_SoMaterialBinding", _wrap_new_SoMaterialBinding, METH_NOARGS, "new_SoMaterialBinding() -> SoMaterialBinding"},
	 { "SoMaterialBinding_value_set", _wrap_SoMaterialBinding_value_set, METH_VARARGS, "SoMaterialBinding_value_set(SoMaterialBinding self, SoSFEnum value)"},
	 { "SoMaterialBinding_value_get", _wrap_SoMaterialBinding_value_get, METH_O, "SoMaterialBinding_value_get(SoMaterialBinding self) -> SoSFEnum"},
	 { "SoMaterialBinding_doAction", _wrap_SoMaterialBinding_doAction, METH_VARARGS, "SoMaterialBinding_doAction(SoMaterialBinding self, SoAction action)"},
	 { "SoMaterialBinding_GLRender", _wrap_SoMaterialBinding_GLRender, METH_VARARGS, "SoMaterialBinding_GLRender(SoMaterialBinding self, SoGLRenderAction action)"},
	 { "SoMaterialBinding_callback", _wrap_SoMaterialBinding_callback, METH_VARARGS, "SoMaterialBinding_callback(SoMaterialBinding self, SoCallbackAction action)"},
	 { "SoMaterialBinding_pick", _wrap_SoMaterialBinding_pick, METH_VARARGS, "SoMaterialBinding_pick(SoMaterialBinding self, SoPickAction action)"},
	 { "SoMaterialBinding_getPrimitiveCount", _wrap_SoMaterialBinding_getPrimitiveCount, METH_VARARGS, "SoMaterialBinding_getPrimitiveCount(SoMaterialBinding self, SoGetPrimitiveCountAction action)"},
	 { "SoMaterialBinding_swigregister", SoMaterialBinding_swigregister, METH_O, NULL},
	 { "SoMaterialBinding_swiginit", SoMaterialBinding_swiginit, METH_VARARGS, NULL},
	 { "SoNormalBindingElement_getClassTypeId", _wrap_SoNormalBindingElement_getClassTypeId, METH_NOARGS, "SoNormalBindingElement_getClassTypeId() -> SoType"},
	 { "SoNormalBindingElement_getClassStackIndex", _wrap_SoNormalBindingElement_getClassStackIndex, METH_NOARGS, "SoNormalBindingElement_getClassStackIndex() -> int"},
	 { "SoNormalBindingElement_createInstance", _wrap_SoNormalBindingElement_createInstance, METH_NOARGS, "SoNormalBindingElement_createInstance() -> void *"},
	 { "SoNormalBindingElement_initClass", _wrap_SoNormalBindingElement_initClass, METH_NOARGS, "SoNormalBindingElement_initClass()"},
	 { "SoNormalBindingElement_init", _wrap_SoNormalBindingElement_init, METH_VARARGS, "SoNormalBindingElement_init(SoNormalBindingElement self, SoState state)"},
	 { "SoNormalBindingElement_set", _wrap_SoNormalBindingElement_set, METH_VARARGS, "\n"
		"SoNormalBindingElement_set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)\n"
		"SoNormalBindingElement_set(SoState state, SoNormalBindingElement::Binding const binding)\n"
		""},
	 { "SoNormalBindingElement_get", _wrap_SoNormalBindingElement_get, METH_O, "SoNormalBindingElement_get(SoState state) -> SoNormalBindingElement::Binding"},
	 { "SoNormalBindingElement_getDefault", _wrap_SoNormalBindingElement_getDefault, METH_NOARGS, "SoNormalBindingElement_getDefault() -> SoNormalBindingElement::Binding"},
	 { "SoNormalBindingElement_swigregister", SoNormalBindingElement_swigregister, METH_O, NULL},
	 { "SoNormalBinding_getClassTypeId", _wrap_SoNormalBinding_getClassTypeId, METH_NOARGS, "SoNormalBinding_getClassTypeId() -> SoType"},
	 { "SoNormalBinding_getTypeId", _wrap_SoNormalBinding_getTypeId, METH_O, "SoNormalBinding_getTypeId(SoNormalBinding self) -> SoType"},
	 { "SoNormalBinding_initClass", _wrap_SoNormalBinding_initClass, METH_NOARGS, "SoNormalBinding_initClass()"},
	 { "new_SoNormalBinding", _wrap_new_SoNormalBinding, METH_NOARGS, "new_SoNormalBinding() -> SoNormalBinding"},
	 { "SoNormalBinding_value_set", _wrap_SoNormalBinding_value_set, METH_VARARGS, "SoNormalBinding_value_set(SoNormalBinding self, SoSFEnum value)"},
	 { "SoNormalBinding_value_get", _wrap_SoNormalBinding_value_get, METH_O, "SoNormalBinding_value_get(SoNormalBinding self) -> SoSFEnum"},
	 { "SoNormalBinding_doAction", _wrap_SoNormalBinding_doAction, METH_VARARGS, "SoNormalBinding_doAction(SoNormalBinding self, SoAction action)"},
	 { "SoNormalBinding_GLRender", _wrap_SoNormalBinding_GLRender, METH_VARARGS, "SoNormalBinding_GLRender(SoNormalBinding self, SoGLRenderAction action)"},
	 { "SoNormalBinding_callback", _wrap_SoNormalBinding_callback, METH_VARARGS, "SoNormalBinding_callback(SoNormalBinding self, SoCallbackAction action)"},
	 { "SoNormalBinding_pick", _wrap_SoNormalBinding_pick, METH_VARARGS, "SoNormalBinding_pick(SoNormalBinding self, SoPickAction action)"},
	 { "SoNormalBinding_getPrimitiveCount", _wrap_SoNormalBinding_getPrimitiveCount, METH_VARARGS, "SoNormalBinding_getPrimitiveCount(SoNormalBinding self, SoGetPrimitiveCountAction action)"},
	 { "SoNormalBinding_swigregister", SoNormalBinding_swigregister, METH_O, NULL},
	 { "SoNormalBinding_swiginit", SoNormalBinding_swiginit, METH_VARARGS, NULL},
	 { "SoPickStyleElement_getClassTypeId", _wrap_SoPickStyleElement_getClassTypeId, METH_NOARGS, "SoPickStyleElement_getClassTypeId() -> SoType"},
	 { "SoPickStyleElement_getClassStackIndex", _wrap_SoPickStyleElement_getClassStackIndex, METH_NOARGS, "SoPickStyleElement_getClassStackIndex() -> int"},
	 { "SoPickStyleElement_createInstance", _wrap_SoPickStyleElement_createInstance, METH_NOARGS, "SoPickStyleElement_createInstance() -> void *"},
	 { "SoPickStyleElement_initClass", _wrap_SoPickStyleElement_initClass, METH_NOARGS, "SoPickStyleElement_initClass()"},
	 { "SoPickStyleElement_init", _wrap_SoPickStyleElement_init, METH_VARARGS, "SoPickStyleElement_init(SoPickStyleElement self, SoState state)"},
	 { "SoPickStyleElement_set", _wrap_SoPickStyleElement_set, METH_VARARGS, "\n"
		"SoPickStyleElement_set(SoState state, SoNode node, int32_t const style)\n"
		"SoPickStyleElement_set(SoState state, SoPickStyleElement::Style const style)\n"
		""},
	 { "SoPickStyleElement_get", _wrap_SoPickStyleElement_get, METH_O, "SoPickStyleElement_get(SoState state) -> SoPickStyleElement::Style"},
	 { "SoPickStyleElement_getDefault", _wrap_SoPickStyleElement_getDefault, METH_NOARGS, "SoPickStyleElement_getDefault() -> SoPickStyleElement::Style"},
	 { "SoPickStyleElement_swigregister", SoPickStyleElement_swigregister, METH_O, NULL},
	 { "SoPickStyle_getClassTypeId", _wrap_SoPickStyle_getClassTypeId, METH_NOARGS, "SoPickStyle_getClassTypeId() -> SoType"},
	 { "SoPickStyle_getTypeId", _wrap_SoPickStyle_getTypeId, METH_O, "SoPickStyle_getTypeId(SoPickStyle self) -> SoType"},
	 { "SoPickStyle_initClass", _wrap_SoPickStyle_initClass, METH_NOARGS, "SoPickStyle_initClass()"},
	 { "new_SoPickStyle", _wrap_new_SoPickStyle, METH_NOARGS, "new_SoPickStyle() -> SoPickStyle"},
	 { "SoPickStyle_style_set", _wrap_SoPickStyle_style_set, METH_VARARGS, "SoPickStyle_style_set(SoPickStyle self, SoSFEnum style)"},
	 { "SoPickStyle_style_get", _wrap_SoPickStyle_style_get, METH_O, "SoPickStyle_style_get(SoPickStyle self) -> SoSFEnum"},
	 { "SoPickStyle_doAction", _wrap_SoPickStyle_doAction, METH_VARARGS, "SoPickStyle_doAction(SoPickStyle self, SoAction action)"},
	 { "SoPickStyle_callback", _wrap_SoPickStyle_callback, METH_VARARGS, "SoPickStyle_callback(SoPickStyle self, SoCallbackAction action)"},
	 { "SoPickStyle_pick", _wrap_SoPickStyle_pick, METH_VARARGS, "SoPickStyle_pick(SoPickStyle self, SoPickAction action)"},
	 { "SoPickStyle_swigregister", SoPickStyle_swigregister, METH_O, NULL},
	 { "SoPickStyle_swiginit", SoPickStyle_swiginit, METH_VARARGS, NULL},
	 { "SoShapeHintsElement_getClassTypeId", _wrap_SoShapeHintsElement_getClassTypeId, METH_NOARGS, "SoShapeHintsElement_getClassTypeId() -> SoType"},
	 { "SoShapeHintsElement_getClassStackIndex", _wrap_SoShapeHintsElement_getClassStackIndex, METH_NOARGS, "SoShapeHintsElement_getClassStackIndex() -> int"},
	 { "SoShapeHintsElement_createInstance", _wrap_SoShapeHintsElement_createInstance, METH_NOARGS, "SoShapeHintsElement_createInstance() -> void *"},
	 { "SoShapeHintsElement_initClass", _wrap_SoShapeHintsElement_initClass, METH_NOARGS, "SoShapeHintsElement_initClass()"},
	 { "SoShapeHintsElement_init", _wrap_SoShapeHintsElement_init, METH_VARARGS, "SoShapeHintsElement_init(SoShapeHintsElement self, SoState state)"},
	 { "SoShapeHintsElement_push", _wrap_SoShapeHintsElement_push, METH_VARARGS, "SoShapeHintsElement_push(SoShapeHintsElement self, SoState state)"},
	 { "SoShapeHintsElement_pop", _wrap_SoShapeHintsElement_pop, METH_VARARGS, "SoShapeHintsElement_pop(SoShapeHintsElement self, SoState state, SoElement prevtopelement)"},
	 { "SoShapeHintsElement_matches", _wrap_SoShapeHintsElement_matches, METH_VARARGS, "SoShapeHintsElement_matches(SoShapeHintsElement self, SoElement element) -> SbBool"},
	 { "SoShapeHintsElement_copyMatchInfo", _wrap_SoShapeHintsElement_copyMatchInfo, METH_O, "SoShapeHintsElement_copyMatchInfo(SoShapeHintsElement self) -> SoElement"},
	 { "SoShapeHintsElement_set", _wrap_SoShapeHintsElement_set, METH_VARARGS, "\n"
		"SoShapeHintsElement_set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)\n"
		"SoShapeHintsElement_set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)\n"
		""},
	 { "SoShapeHintsElement_get", _wrap_SoShapeHintsElement_get, METH_VARARGS, "SoShapeHintsElement_get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"},
	 { "SoShapeHintsElement_getVertexOrdering", _wrap_SoShapeHintsElement_getVertexOrdering, METH_O, "SoShapeHintsElement_getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"},
	 { "SoShapeHintsElement_getShapeType", _wrap_SoShapeHintsElement_getShapeType, METH_O, "SoShapeHintsElement_getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"},
	 { "SoShapeHintsElement_getFaceType", _wrap_SoShapeHintsElement_getFaceType, METH_O, "SoShapeHintsElement_getFaceType(SoState state) -> SoShapeHintsElement::FaceType"},
	 { "SoShapeHintsElement_getDefaultVertexOrdering", _wrap_SoShapeHintsElement_getDefaultVertexOrdering, METH_NOARGS, "SoShapeHintsElement_getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"},
	 { "SoShapeHintsElement_getDefaultShapeType", _wrap_SoShapeHintsElement_getDefaultShapeType, METH_NOARGS, "SoShapeHintsElement_getDefaultShapeType() -> SoShapeHintsElement::ShapeType"},
	 { "SoShapeHintsElement_getDefaultFaceType", _wrap_SoShapeHintsElement_getDefaultFaceType, METH_NOARGS, "SoShapeHintsElement_getDefaultFaceType() -> SoShapeHintsElement::FaceType"},
	 { "SoShapeHintsElement_output", _wrap_SoShapeHintsElement_output, METH_VARARGS, "SoShapeHintsElement_output(SoShapeHintsElement self, FILE * file)"},
	 { "SoShapeHintsElement_swigregister", SoShapeHintsElement_swigregister, METH_O, NULL},
	 { "new_SoSFBool", _wrap_new_SoSFBool, METH_NOARGS, "new_SoSFBool() -> SoSFBool"},
	 { "delete_SoSFBool", _wrap_delete_SoSFBool, METH_O, "delete_SoSFBool(SoSFBool self)"},
	 { "SoSFBool_createInstance", _wrap_SoSFBool_createInstance, METH_NOARGS, "SoSFBool_createInstance() -> void *"},
	 { "SoSFBool_getClassTypeId", _wrap_SoSFBool_getClassTypeId, METH_NOARGS, "SoSFBool_getClassTypeId() -> SoType"},
	 { "SoSFBool_getTypeId", _wrap_SoSFBool_getTypeId, METH_O, "SoSFBool_getTypeId(SoSFBool self) -> SoType"},
	 { "SoSFBool_copyFrom", _wrap_SoSFBool_copyFrom, METH_VARARGS, "SoSFBool_copyFrom(SoSFBool self, SoField field)"},
	 { "SoSFBool_isSame", _wrap_SoSFBool_isSame, METH_VARARGS, "SoSFBool_isSame(SoSFBool self, SoField field) -> SbBool"},
	 { "SoSFBool_getValue", _wrap_SoSFBool_getValue, METH_O, "SoSFBool_getValue(SoSFBool self) -> SbBool"},
	 { "SoSFBool___eq__", _wrap_SoSFBool___eq__, METH_VARARGS, "SoSFBool___eq__(SoSFBool self, SoSFBool field) -> int"},
	 { "SoSFBool___ne__", _wrap_SoSFBool___ne__, METH_VARARGS, "SoSFBool___ne__(SoSFBool self, SoSFBool field) -> int"},
	 { "SoSFBool_initClass", _wrap_SoSFBool_initClass, METH_NOARGS, "SoSFBool_initClass()"},
	 { "SoSFBool_setValue", _wrap_SoSFBool_setValue, METH_VARARGS, "\n"
		"SoSFBool_setValue(SoSFBool self, SbBool newvalue)\n"
		"SoSFBool_setValue(SoSFBool self, SoSFBool other)\n"
		""},
	 { "SoSFBool_swigregister", SoSFBool_swigregister, METH_O, NULL},
	 { "SoSFBool_swiginit", SoSFBool_swiginit, METH_VARARGS, NULL},
	 { "SoShapeHints_getClassTypeId", _wrap_SoShapeHints_getClassTypeId, METH_NOARGS, "SoShapeHints_getClassTypeId() -> SoType"},
	 { "SoShapeHints_getTypeId", _wrap_SoShapeHints_getTypeId, METH_O, "SoShapeHints_getTypeId(SoShapeHints self) -> SoType"},
	 { "SoShapeHints_initClass", _wrap_SoShapeHints_initClass, METH_NOARGS, "SoShapeHints_initClass()"},
	 { "new_SoShapeHints", _wrap_new_SoShapeHints, METH_NOARGS, "new_SoShapeHints() -> SoShapeHints"},
	 { "SoShapeHints_vertexOrdering_set", _wrap_SoShapeHints_vertexOrdering_set, METH_VARARGS, "SoShapeHints_vertexOrdering_set(SoShapeHints self, SoSFEnum vertexOrdering)"},
	 { "SoShapeHints_vertexOrdering_get", _wrap_SoShapeHints_vertexOrdering_get, METH_O, "SoShapeHints_vertexOrdering_get(SoShapeHints self) -> SoSFEnum"},
	 { "SoShapeHints_shapeType_set", _wrap_SoShapeHints_shapeType_set, METH_VARARGS, "SoShapeHints_shapeType_set(SoShapeHints self, SoSFEnum shapeType)"},
	 { "SoShapeHints_shapeType_get", _wrap_SoShapeHints_shapeType_get, METH_O, "SoShapeHints_shapeType_get(SoShapeHints self) -> SoSFEnum"},
	 { "SoShapeHints_faceType_set", _wrap_SoShapeHints_faceType_set, METH_VARARGS, "SoShapeHints_faceType_set(SoShapeHints self, SoSFEnum faceType)"},
	 { "SoShapeHints_faceType_get", _wrap_SoShapeHints_faceType_get, METH_O, "SoShapeHints_faceType_get(SoShapeHints self) -> SoSFEnum"},
	 { "SoShapeHints_windingType_set", _wrap_SoShapeHints_windingType_set, METH_VARARGS, "SoShapeHints_windingType_set(SoShapeHints self, SoSFEnum windingType)"},
	 { "SoShapeHints_windingType_get", _wrap_SoShapeHints_windingType_get, METH_O, "SoShapeHints_windingType_get(SoShapeHints self) -> SoSFEnum"},
	 { "SoShapeHints_useVBO_set", _wrap_SoShapeHints_useVBO_set, METH_VARARGS, "SoShapeHints_useVBO_set(SoShapeHints self, SoSFBool useVBO)"},
	 { "SoShapeHints_useVBO_get", _wrap_SoShapeHints_useVBO_get, METH_O, "SoShapeHints_useVBO_get(SoShapeHints self) -> SoSFBool"},
	 { "SoShapeHints_creaseAngle_set", _wrap_SoShapeHints_creaseAngle_set, METH_VARARGS, "SoShapeHints_creaseAngle_set(SoShapeHints self, SoSFFloat creaseAngle)"},
	 { "SoShapeHints_creaseAngle_get", _wrap_SoShapeHints_creaseAngle_get, METH_O, "SoShapeHints_creaseAngle_get(SoShapeHints self) -> SoSFFloat"},
	 { "SoShapeHints_doAction", _wrap_SoShapeHints_doAction, METH_VARARGS, "SoShapeHints_doAction(SoShapeHints self, SoAction action)"},
	 { "SoShapeHints_GLRender", _wrap_SoShapeHints_GLRender, METH_VARARGS, "SoShapeHints_GLRender(SoShapeHints self, SoGLRenderAction action)"},
	 { "SoShapeHints_callback", _wrap_SoShapeHints_callback, METH_VARARGS, "SoShapeHints_callback(SoShapeHints self, SoCallbackAction action)"},
	 { "SoShapeHints_getBoundingBox", _wrap_SoShapeHints_getBoundingBox, METH_VARARGS, "SoShapeHints_getBoundingBox(SoShapeHints self, SoGetBoundingBoxAction action)"},
	 { "SoShapeHints_pick", _wrap_SoShapeHints_pick, METH_VARARGS, "SoShapeHints_pick(SoShapeHints self, SoPickAction action)"},
	 { "SoShapeHints_swigregister", SoShapeHints_swigregister, METH_O, NULL},
	 { "SoShapeHints_swiginit", SoShapeHints_swiginit, METH_VARARGS, NULL},
	 { "SoTexture_getClassTypeId", _wrap_SoTexture_getClassTypeId, METH_NOARGS, "SoTexture_getClassTypeId() -> SoType"},
	 { "SoTexture_getTypeId", _wrap_SoTexture_getTypeId, METH_O, "SoTexture_getTypeId(SoTexture self) -> SoType"},
	 { "SoTexture_initClass", _wrap_SoTexture_initClass, METH_NOARGS, "SoTexture_initClass()"},
	 { "SoTexture_cleanupClass", _wrap_SoTexture_cleanupClass, METH_NOARGS, "SoTexture_cleanupClass()"},
	 { "SoTexture_doAction", _wrap_SoTexture_doAction, METH_VARARGS, "SoTexture_doAction(SoTexture self, SoAction action)"},
	 { "SoTexture_GLRender", _wrap_SoTexture_GLRender, METH_VARARGS, "SoTexture_GLRender(SoTexture self, SoGLRenderAction action)"},
	 { "SoTexture_callback", _wrap_SoTexture_callback, METH_VARARGS, "SoTexture_callback(SoTexture self, SoCallbackAction action)"},
	 { "SoTexture_swigregister", SoTexture_swigregister, METH_O, NULL},
	 { "new_SoSFImage", _wrap_new_SoSFImage, METH_NOARGS, "new_SoSFImage() -> SoSFImage"},
	 { "delete_SoSFImage", _wrap_delete_SoSFImage, METH_O, "delete_SoSFImage(SoSFImage self)"},
	 { "SoSFImage_createInstance", _wrap_SoSFImage_createInstance, METH_NOARGS, "SoSFImage_createInstance() -> void *"},
	 { "SoSFImage_getClassTypeId", _wrap_SoSFImage_getClassTypeId, METH_NOARGS, "SoSFImage_getClassTypeId() -> SoType"},
	 { "SoSFImage_getTypeId", _wrap_SoSFImage_getTypeId, METH_O, "SoSFImage_getTypeId(SoSFImage self) -> SoType"},
	 { "SoSFImage_copyFrom", _wrap_SoSFImage_copyFrom, METH_VARARGS, "SoSFImage_copyFrom(SoSFImage self, SoField field)"},
	 { "SoSFImage_isSame", _wrap_SoSFImage_isSame, METH_VARARGS, "SoSFImage_isSame(SoSFImage self, SoField field) -> SbBool"},
	 { "SoSFImage_initClass", _wrap_SoSFImage_initClass, METH_NOARGS, "SoSFImage_initClass()"},
	 { "SoSFImage_getValue", _wrap_SoSFImage_getValue, METH_VARARGS, "\n"
		"SoSFImage_getValue(SoSFImage self) -> unsigned char const\n"
		"SoSFImage_getValue(SoSFImage self) -> SbImage\n"
		""},
	 { "SoSFImage___eq__", _wrap_SoSFImage___eq__, METH_VARARGS, "SoSFImage___eq__(SoSFImage self, SoSFImage field) -> int"},
	 { "SoSFImage___ne__", _wrap_SoSFImage___ne__, METH_VARARGS, "SoSFImage___ne__(SoSFImage self, SoSFImage field) -> int"},
	 { "SoSFImage_startEditing", _wrap_SoSFImage_startEditing, METH_O, "SoSFImage_startEditing(SoSFImage self) -> unsigned char *"},
	 { "SoSFImage_finishEditing", _wrap_SoSFImage_finishEditing, METH_O, "SoSFImage_finishEditing(SoSFImage self)"},
	 { "SoSFImage_setSubValue", _wrap_SoSFImage_setSubValue, METH_VARARGS, "SoSFImage_setSubValue(SoSFImage self, SbVec2s dims, SbVec2s offset, unsigned char * pixels)"},
	 { "SoSFImage_setSubValues", _wrap_SoSFImage_setSubValues, METH_VARARGS, "SoSFImage_setSubValues(SoSFImage self, SbVec2s dims, SbVec2s offsets, int num, unsigned char ** pixelblocks)"},
	 { "SoSFImage_getSubTexture", _wrap_SoSFImage_getSubTexture, METH_VARARGS, "SoSFImage_getSubTexture(SoSFImage self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char *"},
	 { "SoSFImage_hasSubTextures", _wrap_SoSFImage_hasSubTextures, METH_VARARGS, "SoSFImage_hasSubTextures(SoSFImage self, int & numsubtextures) -> SbBool"},
	 { "SoSFImage_setNeverWrite", _wrap_SoSFImage_setNeverWrite, METH_VARARGS, "SoSFImage_setNeverWrite(SoSFImage self, SbBool flag)"},
	 { "SoSFImage_isNeverWrite", _wrap_SoSFImage_isNeverWrite, METH_O, "SoSFImage_isNeverWrite(SoSFImage self) -> SbBool"},
	 { "SoSFImage_hasTransparency", _wrap_SoSFImage_hasTransparency, METH_O, "SoSFImage_hasTransparency(SoSFImage self) -> SbBool"},
	 { "SoSFImage_setValue", _wrap_SoSFImage_setValue, METH_VARARGS, "\n"
		"SoSFImage_setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels, SoSFImage::CopyPolicy copypolicy=COPY)\n"
		"SoSFImage_setValue(SoSFImage self, SbVec2s size, int const nc, PyObject * pixels)\n"
		"SoSFImage_setValue(SoSFImage self, SoSFImage other)\n"
		""},
	 { "SoSFImage_swigregister", SoSFImage_swigregister, METH_O, NULL},
	 { "SoSFImage_swiginit", SoSFImage_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFString", _wrap_new_SoSFString, METH_NOARGS, "new_SoSFString() -> SoSFString"},
	 { "delete_SoSFString", _wrap_delete_SoSFString, METH_O, "delete_SoSFString(SoSFString self)"},
	 { "SoSFString_createInstance", _wrap_SoSFString_createInstance, METH_NOARGS, "SoSFString_createInstance() -> void *"},
	 { "SoSFString_getClassTypeId", _wrap_SoSFString_getClassTypeId, METH_NOARGS, "SoSFString_getClassTypeId() -> SoType"},
	 { "SoSFString_getTypeId", _wrap_SoSFString_getTypeId, METH_O, "SoSFString_getTypeId(SoSFString self) -> SoType"},
	 { "SoSFString_copyFrom", _wrap_SoSFString_copyFrom, METH_VARARGS, "SoSFString_copyFrom(SoSFString self, SoField field)"},
	 { "SoSFString_isSame", _wrap_SoSFString_isSame, METH_VARARGS, "SoSFString_isSame(SoSFString self, SoField field) -> SbBool"},
	 { "SoSFString_getValue", _wrap_SoSFString_getValue, METH_O, "SoSFString_getValue(SoSFString self) -> SbString"},
	 { "SoSFString___eq__", _wrap_SoSFString___eq__, METH_VARARGS, "SoSFString___eq__(SoSFString self, SoSFString field) -> int"},
	 { "SoSFString___ne__", _wrap_SoSFString___ne__, METH_VARARGS, "SoSFString___ne__(SoSFString self, SoSFString field) -> int"},
	 { "SoSFString_initClass", _wrap_SoSFString_initClass, METH_NOARGS, "SoSFString_initClass()"},
	 { "SoSFString_setValue", _wrap_SoSFString_setValue, METH_VARARGS, "\n"
		"SoSFString_setValue(SoSFString self, SbString newvalue)\n"
		"SoSFString_setValue(SoSFString self, char const * str)\n"
		"SoSFString_setValue(SoSFString self, SoSFString other)\n"
		""},
	 { "SoSFString_swigregister", SoSFString_swigregister, METH_O, NULL},
	 { "SoSFString_swiginit", SoSFString_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFColor", _wrap_new_SoSFColor, METH_NOARGS, "new_SoSFColor() -> SoSFColor"},
	 { "delete_SoSFColor", _wrap_delete_SoSFColor, METH_O, "delete_SoSFColor(SoSFColor self)"},
	 { "SoSFColor_createInstance", _wrap_SoSFColor_createInstance, METH_NOARGS, "SoSFColor_createInstance() -> void *"},
	 { "SoSFColor_getClassTypeId", _wrap_SoSFColor_getClassTypeId, METH_NOARGS, "SoSFColor_getClassTypeId() -> SoType"},
	 { "SoSFColor_getTypeId", _wrap_SoSFColor_getTypeId, METH_O, "SoSFColor_getTypeId(SoSFColor self) -> SoType"},
	 { "SoSFColor_copyFrom", _wrap_SoSFColor_copyFrom, METH_VARARGS, "SoSFColor_copyFrom(SoSFColor self, SoField field)"},
	 { "SoSFColor_isSame", _wrap_SoSFColor_isSame, METH_VARARGS, "SoSFColor_isSame(SoSFColor self, SoField field) -> SbBool"},
	 { "SoSFColor_getValue", _wrap_SoSFColor_getValue, METH_O, "SoSFColor_getValue(SoSFColor self) -> SbColor"},
	 { "SoSFColor___eq__", _wrap_SoSFColor___eq__, METH_VARARGS, "SoSFColor___eq__(SoSFColor self, SoSFColor field) -> int"},
	 { "SoSFColor___ne__", _wrap_SoSFColor___ne__, METH_VARARGS, "SoSFColor___ne__(SoSFColor self, SoSFColor field) -> int"},
	 { "SoSFColor_initClass", _wrap_SoSFColor_initClass, METH_NOARGS, "SoSFColor_initClass()"},
	 { "SoSFColor_setHSVValue", _wrap_SoSFColor_setHSVValue, METH_VARARGS, "\n"
		"SoSFColor_setHSVValue(SoSFColor self, float h, float s, float v)\n"
		"SoSFColor_setHSVValue(SoSFColor self, float const [3] hsv)\n"
		""},
	 { "SoSFColor_setValue", _wrap_SoSFColor_setValue, METH_VARARGS, "\n"
		"SoSFColor_setValue(SoSFColor self, SbColor newvalue)\n"
		"SoSFColor_setValue(SoSFColor self, SbVec3f vec)\n"
		"SoSFColor_setValue(SoSFColor self, float red, float green, float blue)\n"
		"SoSFColor_setValue(SoSFColor self, float const [3] rgb)\n"
		"SoSFColor_setValue(SoSFColor self, SoSFColor other)\n"
		""},
	 { "SoSFColor_swigregister", SoSFColor_swigregister, METH_O, NULL},
	 { "SoSFColor_swiginit", SoSFColor_swiginit, METH_VARARGS, NULL},
	 { "SoReplacedElement_getClassTypeId", _wrap_SoReplacedElement_getClassTypeId, METH_NOARGS, "SoReplacedElement_getClassTypeId() -> SoType"},
	 { "SoReplacedElement_getClassStackIndex", _wrap_SoReplacedElement_getClassStackIndex, METH_NOARGS, "SoReplacedElement_getClassStackIndex() -> int"},
	 { "SoReplacedElement_initClass", _wrap_SoReplacedElement_initClass, METH_NOARGS, "SoReplacedElement_initClass()"},
	 { "SoReplacedElement_init", _wrap_SoReplacedElement_init, METH_VARARGS, "SoReplacedElement_init(SoReplacedElement self, SoState state)"},
	 { "SoReplacedElement_matches", _wrap_SoReplacedElement_matches, METH_VARARGS, "SoReplacedElement_matches(SoReplacedElement self, SoElement element) -> SbBool"},
	 { "SoReplacedElement_copyMatchInfo", _wrap_SoReplacedElement_copyMatchInfo, METH_O, "SoReplacedElement_copyMatchInfo(SoReplacedElement self) -> SoElement"},
	 { "SoReplacedElement_getNodeId", _wrap_SoReplacedElement_getNodeId, METH_O, "SoReplacedElement_getNodeId(SoReplacedElement self) -> SbUniqueId"},
	 { "SoReplacedElement_output", _wrap_SoReplacedElement_output, METH_VARARGS, "SoReplacedElement_output(SoReplacedElement self, FILE * file)"},
	 { "SoReplacedElement_swigregister", SoReplacedElement_swigregister, METH_O, NULL},
	 { "new_SbVec3s", _wrap_new_SbVec3s, METH_VARARGS, "\n"
		"SbVec3s()\n"
		"SbVec3s(short const [3] v)\n"
		"SbVec3s(short x, short y, short z)\n"
		"SbVec3s(SbVec3us const & v)\n"
		"SbVec3s(SbVec3b v)\n"
		"SbVec3s(SbVec3i32 v)\n"
		"SbVec3s(SbVec3f v)\n"
		"new_SbVec3s(SbVec3d v) -> SbVec3s\n"
		""},
	 { "SbVec3s_setValue", _wrap_SbVec3s_setValue, METH_VARARGS, "\n"
		"SbVec3s_setValue(SbVec3s self, short const [3] v) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, short x, short y, short z) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, SbVec3us const & v) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, SbVec3b v) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, SbVec3i32 v) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, SbVec3f v) -> SbVec3s\n"
		"SbVec3s_setValue(SbVec3s self, SbVec3d v) -> SbVec3s\n"
		""},
	 { "SbVec3s_getValue", _wrap_SbVec3s_getValue, METH_VARARGS, "\n"
		"SbVec3s_getValue(SbVec3s self) -> short const\n"
		"SbVec3s_getValue(SbVec3s self)\n"
		""},
	 { "SbVec3s_dot", _wrap_SbVec3s_dot, METH_VARARGS, "SbVec3s_dot(SbVec3s self, SbVec3s v) -> int32_t"},
	 { "SbVec3s_negate", _wrap_SbVec3s_negate, METH_O, "SbVec3s_negate(SbVec3s self)"},
	 { "SbVec3s___imul__", _wrap_SbVec3s___imul__, METH_VARARGS, "\n"
		"SbVec3s___imul__(SbVec3s self, int d) -> SbVec3s\n"
		"SbVec3s___imul__(SbVec3s self, double d) -> SbVec3s\n"
		""},
	 { "SbVec3s___itruediv__", _wrap_SbVec3s___itruediv__, METH_VARARGS, "\n"
		"SbVec3s___itruediv__(SbVec3s self, int d) -> SbVec3s\n"
		"SbVec3s___itruediv__(SbVec3s self, double d) -> SbVec3s\n"
		""},
	 { "SbVec3s___iadd__", _wrap_SbVec3s___iadd__, METH_VARARGS, "SbVec3s___iadd__(SbVec3s self, SbVec3s v) -> SbVec3s"},
	 { "SbVec3s___isub__", _wrap_SbVec3s___isub__, METH_VARARGS, "SbVec3s___isub__(SbVec3s self, SbVec3s v) -> SbVec3s"},
	 { "SbVec3s___neg__", _wrap_SbVec3s___neg__, METH_O, "SbVec3s___neg__(SbVec3s self) -> SbVec3s"},
	 { "SbVec3s_toString", _wrap_SbVec3s_toString, METH_O, "SbVec3s_toString(SbVec3s self) -> SbString"},
	 { "SbVec3s_fromString", _wrap_SbVec3s_fromString, METH_VARARGS, "SbVec3s_fromString(SbVec3s self, SbString str) -> SbBool"},
	 { "SbVec3s_output", _wrap_SbVec3s_output, METH_VARARGS, "SbVec3s_output(SbVec3s self, FILE * fp)"},
	 { "SbVec3s___add__", _wrap_SbVec3s___add__, METH_VARARGS, "SbVec3s___add__(SbVec3s self, SbVec3s u) -> SbVec3s"},
	 { "SbVec3s___sub__", _wrap_SbVec3s___sub__, METH_VARARGS, "SbVec3s___sub__(SbVec3s self, SbVec3s u) -> SbVec3s"},
	 { "SbVec3s___mul__", _wrap_SbVec3s___mul__, METH_VARARGS, "SbVec3s___mul__(SbVec3s self, double const d) -> SbVec3s"},
	 { "SbVec3s___rmul__", _wrap_SbVec3s___rmul__, METH_VARARGS, "SbVec3s___rmul__(SbVec3s self, double const d) -> SbVec3s"},
	 { "SbVec3s___div__", _wrap_SbVec3s___div__, METH_VARARGS, "SbVec3s___div__(SbVec3s self, double const d) -> SbVec3s"},
	 { "SbVec3s___truediv__", _wrap_SbVec3s___truediv__, METH_VARARGS, "SbVec3s___truediv__(SbVec3s self, double const d) -> SbVec3s"},
	 { "SbVec3s___eq__", _wrap_SbVec3s___eq__, METH_VARARGS, "SbVec3s___eq__(SbVec3s self, SbVec3s u) -> int"},
	 { "SbVec3s___nq__", _wrap_SbVec3s___nq__, METH_VARARGS, "SbVec3s___nq__(SbVec3s self, SbVec3s u) -> int"},
	 { "SbVec3s___getitem__", _wrap_SbVec3s___getitem__, METH_VARARGS, "SbVec3s___getitem__(SbVec3s self, int i) -> short"},
	 { "SbVec3s___setitem__", _wrap_SbVec3s___setitem__, METH_VARARGS, "SbVec3s___setitem__(SbVec3s self, int i, short value)"},
	 { "delete_SbVec3s", _wrap_delete_SbVec3s, METH_O, "delete_SbVec3s(SbVec3s self)"},
	 { "SbVec3s_swigregister", SbVec3s_swigregister, METH_O, NULL},
	 { "SbVec3s_swiginit", SbVec3s_swiginit, METH_VARARGS, NULL},
	 { "SoMultiTextureImageElement_getClassTypeId", _wrap_SoMultiTextureImageElement_getClassTypeId, METH_NOARGS, "SoMultiTextureImageElement_getClassTypeId() -> SoType"},
	 { "SoMultiTextureImageElement_getClassStackIndex", _wrap_SoMultiTextureImageElement_getClassStackIndex, METH_NOARGS, "SoMultiTextureImageElement_getClassStackIndex() -> int"},
	 { "SoMultiTextureImageElement_createInstance", _wrap_SoMultiTextureImageElement_createInstance, METH_NOARGS, "SoMultiTextureImageElement_createInstance() -> void *"},
	 { "SoMultiTextureImageElement_initClass", _wrap_SoMultiTextureImageElement_initClass, METH_NOARGS, "SoMultiTextureImageElement_initClass()"},
	 { "SoMultiTextureImageElement_init", _wrap_SoMultiTextureImageElement_init, METH_VARARGS, "SoMultiTextureImageElement_init(SoMultiTextureImageElement self, SoState state)"},
	 { "SoMultiTextureImageElement_setDefault", _wrap_SoMultiTextureImageElement_setDefault, METH_VARARGS, "SoMultiTextureImageElement_setDefault(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureImageElement_getBlendColor", _wrap_SoMultiTextureImageElement_getBlendColor, METH_VARARGS, "SoMultiTextureImageElement_getBlendColor(SoState state, int const unit=0) -> SbColor"},
	 { "SoMultiTextureImageElement_getModel", _wrap_SoMultiTextureImageElement_getModel, METH_VARARGS, "SoMultiTextureImageElement_getModel(SoState state, int const unit=0) -> SoMultiTextureImageElement::Model"},
	 { "SoMultiTextureImageElement_getWrapS", _wrap_SoMultiTextureImageElement_getWrapS, METH_VARARGS, "SoMultiTextureImageElement_getWrapS(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"},
	 { "SoMultiTextureImageElement_getWrapT", _wrap_SoMultiTextureImageElement_getWrapT, METH_VARARGS, "SoMultiTextureImageElement_getWrapT(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"},
	 { "SoMultiTextureImageElement_getWrapR", _wrap_SoMultiTextureImageElement_getWrapR, METH_VARARGS, "SoMultiTextureImageElement_getWrapR(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap"},
	 { "SoMultiTextureImageElement_containsTransparency", _wrap_SoMultiTextureImageElement_containsTransparency, METH_O, "SoMultiTextureImageElement_containsTransparency(SoState state) -> SbBool"},
	 { "SoMultiTextureImageElement_getDefault", _wrap_SoMultiTextureImageElement_getDefault, METH_VARARGS, "\n"
		"SoMultiTextureImageElement_getDefault(SbVec2s size, int & numComponents) -> unsigned char const\n"
		"SoMultiTextureImageElement_getDefault(SbVec3s size, int & numComponents) -> unsigned char const *\n"
		""},
	 { "SoMultiTextureImageElement_push", _wrap_SoMultiTextureImageElement_push, METH_VARARGS, "SoMultiTextureImageElement_push(SoMultiTextureImageElement self, SoState state)"},
	 { "SoMultiTextureImageElement_matches", _wrap_SoMultiTextureImageElement_matches, METH_VARARGS, "SoMultiTextureImageElement_matches(SoMultiTextureImageElement self, SoElement elem) -> SbBool"},
	 { "SoMultiTextureImageElement_copyMatchInfo", _wrap_SoMultiTextureImageElement_copyMatchInfo, METH_O, "SoMultiTextureImageElement_copyMatchInfo(SoMultiTextureImageElement self) -> SoElement"},
	 { "SoMultiTextureImageElement_setElt", _wrap_SoMultiTextureImageElement_setElt, METH_VARARGS, "\n"
		"SoMultiTextureImageElement_setElt(SoMultiTextureImageElement self, int const unit, SbUniqueId const nodeid, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_setElt(SoMultiTextureImageElement self, int const unit, SbUniqueId const nodeid, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		""},
	 { "SoMultiTextureImageElement_hasTransparency", _wrap_SoMultiTextureImageElement_hasTransparency, METH_VARARGS, "SoMultiTextureImageElement_hasTransparency(SoMultiTextureImageElement self, int const unit=0) -> SbBool"},
	 { "SoMultiTextureImageElement_set", _wrap_SoMultiTextureImageElement_set, METH_VARARGS, "\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)\n"
		"SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		""},
	 { "SoMultiTextureImageElement_get", _wrap_SoMultiTextureImageElement_get, METH_VARARGS, "\n"
		"SoMultiTextureImageElement_get(SoState state, int const unit, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const\n"
		"SoMultiTextureImageElement_get(SoState state, int const unit, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const\n"
		"SoMultiTextureImageElement_get(SoState state, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const\n"
		"SoMultiTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const\n"
		"SoMultiTextureImageElement_get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const\n"
		"SoMultiTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *\n"
		""},
	 { "SoMultiTextureImageElement_getImage", _wrap_SoMultiTextureImageElement_getImage, METH_VARARGS, "\n"
		"SoMultiTextureImageElement_getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const\n"
		"SoMultiTextureImageElement_getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const\n"
		"SoMultiTextureImageElement_getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const\n"
		"SoMultiTextureImageElement_getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *\n"
		""},
	 { "SoMultiTextureImageElement_swigregister", SoMultiTextureImageElement_swigregister, METH_O, NULL},
	 { "SoTexture2_getClassTypeId", _wrap_SoTexture2_getClassTypeId, METH_NOARGS, "SoTexture2_getClassTypeId() -> SoType"},
	 { "SoTexture2_getTypeId", _wrap_SoTexture2_getTypeId, METH_O, "SoTexture2_getTypeId(SoTexture2 self) -> SoType"},
	 { "SoTexture2_initClass", _wrap_SoTexture2_initClass, METH_NOARGS, "SoTexture2_initClass()"},
	 { "new_SoTexture2", _wrap_new_SoTexture2, METH_NOARGS, "new_SoTexture2() -> SoTexture2"},
	 { "SoTexture2_filename_set", _wrap_SoTexture2_filename_set, METH_VARARGS, "SoTexture2_filename_set(SoTexture2 self, SoSFString filename)"},
	 { "SoTexture2_filename_get", _wrap_SoTexture2_filename_get, METH_O, "SoTexture2_filename_get(SoTexture2 self) -> SoSFString"},
	 { "SoTexture2_image_set", _wrap_SoTexture2_image_set, METH_VARARGS, "SoTexture2_image_set(SoTexture2 self, SoSFImage image)"},
	 { "SoTexture2_image_get", _wrap_SoTexture2_image_get, METH_O, "SoTexture2_image_get(SoTexture2 self) -> SoSFImage"},
	 { "SoTexture2_wrapS_set", _wrap_SoTexture2_wrapS_set, METH_VARARGS, "SoTexture2_wrapS_set(SoTexture2 self, SoSFEnum wrapS)"},
	 { "SoTexture2_wrapS_get", _wrap_SoTexture2_wrapS_get, METH_O, "SoTexture2_wrapS_get(SoTexture2 self) -> SoSFEnum"},
	 { "SoTexture2_wrapT_set", _wrap_SoTexture2_wrapT_set, METH_VARARGS, "SoTexture2_wrapT_set(SoTexture2 self, SoSFEnum wrapT)"},
	 { "SoTexture2_wrapT_get", _wrap_SoTexture2_wrapT_get, METH_O, "SoTexture2_wrapT_get(SoTexture2 self) -> SoSFEnum"},
	 { "SoTexture2_model_set", _wrap_SoTexture2_model_set, METH_VARARGS, "SoTexture2_model_set(SoTexture2 self, SoSFEnum model)"},
	 { "SoTexture2_model_get", _wrap_SoTexture2_model_get, METH_O, "SoTexture2_model_get(SoTexture2 self) -> SoSFEnum"},
	 { "SoTexture2_blendColor_set", _wrap_SoTexture2_blendColor_set, METH_VARARGS, "SoTexture2_blendColor_set(SoTexture2 self, SoSFColor blendColor)"},
	 { "SoTexture2_blendColor_get", _wrap_SoTexture2_blendColor_get, METH_O, "SoTexture2_blendColor_get(SoTexture2 self) -> SoSFColor"},
	 { "SoTexture2_enableCompressedTexture_set", _wrap_SoTexture2_enableCompressedTexture_set, METH_VARARGS, "SoTexture2_enableCompressedTexture_set(SoTexture2 self, SoSFBool enableCompressedTexture)"},
	 { "SoTexture2_enableCompressedTexture_get", _wrap_SoTexture2_enableCompressedTexture_get, METH_O, "SoTexture2_enableCompressedTexture_get(SoTexture2 self) -> SoSFBool"},
	 { "SoTexture2_doAction", _wrap_SoTexture2_doAction, METH_VARARGS, "SoTexture2_doAction(SoTexture2 self, SoAction action)"},
	 { "SoTexture2_GLRender", _wrap_SoTexture2_GLRender, METH_VARARGS, "SoTexture2_GLRender(SoTexture2 self, SoGLRenderAction action)"},
	 { "SoTexture2_callback", _wrap_SoTexture2_callback, METH_VARARGS, "SoTexture2_callback(SoTexture2 self, SoCallbackAction action)"},
	 { "SoTexture2_rayPick", _wrap_SoTexture2_rayPick, METH_VARARGS, "SoTexture2_rayPick(SoTexture2 self, SoRayPickAction action)"},
	 { "SoTexture2_readImage", _wrap_SoTexture2_readImage, METH_VARARGS, "SoTexture2_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"},
	 { "SoTexture2_swigregister", SoTexture2_swigregister, METH_O, NULL},
	 { "SoTexture2_swiginit", SoTexture2_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateBindingElement_getClassTypeId", _wrap_SoTextureCoordinateBindingElement_getClassTypeId, METH_NOARGS, "SoTextureCoordinateBindingElement_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateBindingElement_getClassStackIndex", _wrap_SoTextureCoordinateBindingElement_getClassStackIndex, METH_NOARGS, "SoTextureCoordinateBindingElement_getClassStackIndex() -> int"},
	 { "SoTextureCoordinateBindingElement_createInstance", _wrap_SoTextureCoordinateBindingElement_createInstance, METH_NOARGS, "SoTextureCoordinateBindingElement_createInstance() -> void *"},
	 { "SoTextureCoordinateBindingElement_initClass", _wrap_SoTextureCoordinateBindingElement_initClass, METH_NOARGS, "SoTextureCoordinateBindingElement_initClass()"},
	 { "SoTextureCoordinateBindingElement_init", _wrap_SoTextureCoordinateBindingElement_init, METH_VARARGS, "SoTextureCoordinateBindingElement_init(SoTextureCoordinateBindingElement self, SoState state)"},
	 { "SoTextureCoordinateBindingElement_set", _wrap_SoTextureCoordinateBindingElement_set, METH_VARARGS, "\n"
		"SoTextureCoordinateBindingElement_set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)\n"
		"SoTextureCoordinateBindingElement_set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)\n"
		""},
	 { "SoTextureCoordinateBindingElement_get", _wrap_SoTextureCoordinateBindingElement_get, METH_O, "SoTextureCoordinateBindingElement_get(SoState state) -> SoTextureCoordinateBindingElement::Binding"},
	 { "SoTextureCoordinateBindingElement_getDefault", _wrap_SoTextureCoordinateBindingElement_getDefault, METH_NOARGS, "SoTextureCoordinateBindingElement_getDefault() -> SoTextureCoordinateBindingElement::Binding"},
	 { "SoTextureCoordinateBindingElement_swigregister", SoTextureCoordinateBindingElement_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateBinding_getClassTypeId", _wrap_SoTextureCoordinateBinding_getClassTypeId, METH_NOARGS, "SoTextureCoordinateBinding_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateBinding_getTypeId", _wrap_SoTextureCoordinateBinding_getTypeId, METH_O, "SoTextureCoordinateBinding_getTypeId(SoTextureCoordinateBinding self) -> SoType"},
	 { "SoTextureCoordinateBinding_initClass", _wrap_SoTextureCoordinateBinding_initClass, METH_NOARGS, "SoTextureCoordinateBinding_initClass()"},
	 { "new_SoTextureCoordinateBinding", _wrap_new_SoTextureCoordinateBinding, METH_NOARGS, "new_SoTextureCoordinateBinding() -> SoTextureCoordinateBinding"},
	 { "SoTextureCoordinateBinding_value_set", _wrap_SoTextureCoordinateBinding_value_set, METH_VARARGS, "SoTextureCoordinateBinding_value_set(SoTextureCoordinateBinding self, SoSFEnum value)"},
	 { "SoTextureCoordinateBinding_value_get", _wrap_SoTextureCoordinateBinding_value_get, METH_O, "SoTextureCoordinateBinding_value_get(SoTextureCoordinateBinding self) -> SoSFEnum"},
	 { "SoTextureCoordinateBinding_doAction", _wrap_SoTextureCoordinateBinding_doAction, METH_VARARGS, "SoTextureCoordinateBinding_doAction(SoTextureCoordinateBinding self, SoAction action)"},
	 { "SoTextureCoordinateBinding_callback", _wrap_SoTextureCoordinateBinding_callback, METH_VARARGS, "SoTextureCoordinateBinding_callback(SoTextureCoordinateBinding self, SoCallbackAction action)"},
	 { "SoTextureCoordinateBinding_GLRender", _wrap_SoTextureCoordinateBinding_GLRender, METH_VARARGS, "SoTextureCoordinateBinding_GLRender(SoTextureCoordinateBinding self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateBinding_pick", _wrap_SoTextureCoordinateBinding_pick, METH_VARARGS, "SoTextureCoordinateBinding_pick(SoTextureCoordinateBinding self, SoPickAction action)"},
	 { "SoTextureCoordinateBinding_swigregister", SoTextureCoordinateBinding_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateBinding_swiginit", SoTextureCoordinateBinding_swiginit, METH_VARARGS, NULL},
	 { "SoTransformation_getClassTypeId", _wrap_SoTransformation_getClassTypeId, METH_NOARGS, "SoTransformation_getClassTypeId() -> SoType"},
	 { "SoTransformation_getTypeId", _wrap_SoTransformation_getTypeId, METH_O, "SoTransformation_getTypeId(SoTransformation self) -> SoType"},
	 { "SoTransformation_initClass", _wrap_SoTransformation_initClass, METH_NOARGS, "SoTransformation_initClass()"},
	 { "SoTransformation_swigregister", SoTransformation_swigregister, METH_O, NULL},
	 { "SoUnits_getClassTypeId", _wrap_SoUnits_getClassTypeId, METH_NOARGS, "SoUnits_getClassTypeId() -> SoType"},
	 { "SoUnits_getTypeId", _wrap_SoUnits_getTypeId, METH_O, "SoUnits_getTypeId(SoUnits self) -> SoType"},
	 { "SoUnits_initClass", _wrap_SoUnits_initClass, METH_NOARGS, "SoUnits_initClass()"},
	 { "new_SoUnits", _wrap_new_SoUnits, METH_NOARGS, "new_SoUnits() -> SoUnits"},
	 { "SoUnits_units_set", _wrap_SoUnits_units_set, METH_VARARGS, "SoUnits_units_set(SoUnits self, SoSFEnum units)"},
	 { "SoUnits_units_get", _wrap_SoUnits_units_get, METH_O, "SoUnits_units_get(SoUnits self) -> SoSFEnum"},
	 { "SoUnits_doAction", _wrap_SoUnits_doAction, METH_VARARGS, "SoUnits_doAction(SoUnits self, SoAction action)"},
	 { "SoUnits_callback", _wrap_SoUnits_callback, METH_VARARGS, "SoUnits_callback(SoUnits self, SoCallbackAction action)"},
	 { "SoUnits_getBoundingBox", _wrap_SoUnits_getBoundingBox, METH_VARARGS, "SoUnits_getBoundingBox(SoUnits self, SoGetBoundingBoxAction action)"},
	 { "SoUnits_getMatrix", _wrap_SoUnits_getMatrix, METH_VARARGS, "SoUnits_getMatrix(SoUnits self, SoGetMatrixAction action)"},
	 { "SoUnits_GLRender", _wrap_SoUnits_GLRender, METH_VARARGS, "SoUnits_GLRender(SoUnits self, SoGLRenderAction action)"},
	 { "SoUnits_pick", _wrap_SoUnits_pick, METH_VARARGS, "SoUnits_pick(SoUnits self, SoPickAction action)"},
	 { "SoUnits_getPrimitiveCount", _wrap_SoUnits_getPrimitiveCount, METH_VARARGS, "SoUnits_getPrimitiveCount(SoUnits self, SoGetPrimitiveCountAction action)"},
	 { "SoUnits_swigregister", SoUnits_swigregister, METH_O, NULL},
	 { "SoUnits_swiginit", SoUnits_swiginit, METH_VARARGS, NULL},
	 { "SoCallbackAction_getTypeId", _wrap_SoCallbackAction_getTypeId, METH_O, "SoCallbackAction_getTypeId(SoCallbackAction self) -> SoType"},
	 { "SoCallbackAction_getClassTypeId", _wrap_SoCallbackAction_getClassTypeId, METH_NOARGS, "SoCallbackAction_getClassTypeId() -> SoType"},
	 { "SoCallbackAction_addMethod", _wrap_SoCallbackAction_addMethod, METH_VARARGS, "SoCallbackAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoCallbackAction_enableElement", _wrap_SoCallbackAction_enableElement, METH_VARARGS, "SoCallbackAction_enableElement(SoType type, int const stackindex)"},
	 { "SoCallbackAction_initClass", _wrap_SoCallbackAction_initClass, METH_NOARGS, "SoCallbackAction_initClass()"},
	 { "new_SoCallbackAction", _wrap_new_SoCallbackAction, METH_VARARGS, "\n"
		"SoCallbackAction()\n"
		"new_SoCallbackAction(SbViewportRegion vp) -> SoCallbackAction\n"
		""},
	 { "delete_SoCallbackAction", _wrap_delete_SoCallbackAction, METH_O, "delete_SoCallbackAction(SoCallbackAction self)"},
	 { "SoCallbackAction_setViewportRegion", _wrap_SoCallbackAction_setViewportRegion, METH_VARARGS, "SoCallbackAction_setViewportRegion(SoCallbackAction self, SbViewportRegion vp)"},
	 { "SoCallbackAction_getDecimationType", _wrap_SoCallbackAction_getDecimationType, METH_O, "SoCallbackAction_getDecimationType(SoCallbackAction self) -> SoDecimationTypeElement::Type"},
	 { "SoCallbackAction_getDecimationPercentage", _wrap_SoCallbackAction_getDecimationPercentage, METH_O, "SoCallbackAction_getDecimationPercentage(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getComplexity", _wrap_SoCallbackAction_getComplexity, METH_O, "SoCallbackAction_getComplexity(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getComplexityType", _wrap_SoCallbackAction_getComplexityType, METH_O, "SoCallbackAction_getComplexityType(SoCallbackAction self) -> SoComplexity::Type"},
	 { "SoCallbackAction_getNumCoordinates", _wrap_SoCallbackAction_getNumCoordinates, METH_O, "SoCallbackAction_getNumCoordinates(SoCallbackAction self) -> int32_t"},
	 { "SoCallbackAction_getCoordinate3", _wrap_SoCallbackAction_getCoordinate3, METH_VARARGS, "SoCallbackAction_getCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"},
	 { "SoCallbackAction_getCoordinate4", _wrap_SoCallbackAction_getCoordinate4, METH_VARARGS, "SoCallbackAction_getCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"},
	 { "SoCallbackAction_getDrawStyle", _wrap_SoCallbackAction_getDrawStyle, METH_O, "SoCallbackAction_getDrawStyle(SoCallbackAction self) -> SoDrawStyle::Style"},
	 { "SoCallbackAction_getLinePattern", _wrap_SoCallbackAction_getLinePattern, METH_O, "SoCallbackAction_getLinePattern(SoCallbackAction self) -> unsigned short"},
	 { "SoCallbackAction_getLineWidth", _wrap_SoCallbackAction_getLineWidth, METH_O, "SoCallbackAction_getLineWidth(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getPointSize", _wrap_SoCallbackAction_getPointSize, METH_O, "SoCallbackAction_getPointSize(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getFontName", _wrap_SoCallbackAction_getFontName, METH_O, "SoCallbackAction_getFontName(SoCallbackAction self) -> SbName"},
	 { "SoCallbackAction_getFontSize", _wrap_SoCallbackAction_getFontSize, METH_O, "SoCallbackAction_getFontSize(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getLightModel", _wrap_SoCallbackAction_getLightModel, METH_O, "SoCallbackAction_getLightModel(SoCallbackAction self) -> SoLightModel::Model"},
	 { "SoCallbackAction_getLightAttenuation", _wrap_SoCallbackAction_getLightAttenuation, METH_O, "SoCallbackAction_getLightAttenuation(SoCallbackAction self) -> SbVec3f"},
	 { "SoCallbackAction_getMaterialBinding", _wrap_SoCallbackAction_getMaterialBinding, METH_O, "SoCallbackAction_getMaterialBinding(SoCallbackAction self) -> SoMaterialBinding::Binding"},
	 { "SoCallbackAction_getNumNormals", _wrap_SoCallbackAction_getNumNormals, METH_O, "SoCallbackAction_getNumNormals(SoCallbackAction self) -> uint32_t"},
	 { "SoCallbackAction_getNormal", _wrap_SoCallbackAction_getNormal, METH_VARARGS, "SoCallbackAction_getNormal(SoCallbackAction self, int const index) -> SbVec3f"},
	 { "SoCallbackAction_getNormalBinding", _wrap_SoCallbackAction_getNormalBinding, METH_O, "SoCallbackAction_getNormalBinding(SoCallbackAction self) -> SoNormalBinding::Binding"},
	 { "SoCallbackAction_getNumProfileCoordinates", _wrap_SoCallbackAction_getNumProfileCoordinates, METH_O, "SoCallbackAction_getNumProfileCoordinates(SoCallbackAction self) -> int32_t"},
	 { "SoCallbackAction_getProfileCoordinate2", _wrap_SoCallbackAction_getProfileCoordinate2, METH_VARARGS, "SoCallbackAction_getProfileCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"},
	 { "SoCallbackAction_getProfileCoordinate3", _wrap_SoCallbackAction_getProfileCoordinate3, METH_VARARGS, "SoCallbackAction_getProfileCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"},
	 { "SoCallbackAction_getProfile", _wrap_SoCallbackAction_getProfile, METH_O, "SoCallbackAction_getProfile(SoCallbackAction self) -> SoNodeList"},
	 { "SoCallbackAction_getVertexOrdering", _wrap_SoCallbackAction_getVertexOrdering, METH_O, "SoCallbackAction_getVertexOrdering(SoCallbackAction self) -> SoShapeHints::VertexOrdering"},
	 { "SoCallbackAction_getShapeType", _wrap_SoCallbackAction_getShapeType, METH_O, "SoCallbackAction_getShapeType(SoCallbackAction self) -> SoShapeHints::ShapeType"},
	 { "SoCallbackAction_getFaceType", _wrap_SoCallbackAction_getFaceType, METH_O, "SoCallbackAction_getFaceType(SoCallbackAction self) -> SoShapeHints::FaceType"},
	 { "SoCallbackAction_getCreaseAngle", _wrap_SoCallbackAction_getCreaseAngle, METH_O, "SoCallbackAction_getCreaseAngle(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getNumTextureCoordinates", _wrap_SoCallbackAction_getNumTextureCoordinates, METH_O, "SoCallbackAction_getNumTextureCoordinates(SoCallbackAction self) -> int32_t"},
	 { "SoCallbackAction_getTextureCoordinate2", _wrap_SoCallbackAction_getTextureCoordinate2, METH_VARARGS, "SoCallbackAction_getTextureCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"},
	 { "SoCallbackAction_getTextureCoordinate3", _wrap_SoCallbackAction_getTextureCoordinate3, METH_VARARGS, "SoCallbackAction_getTextureCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"},
	 { "SoCallbackAction_getTextureCoordinate4", _wrap_SoCallbackAction_getTextureCoordinate4, METH_VARARGS, "SoCallbackAction_getTextureCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"},
	 { "SoCallbackAction_getTextureCoordinateBinding", _wrap_SoCallbackAction_getTextureCoordinateBinding, METH_O, "SoCallbackAction_getTextureCoordinateBinding(SoCallbackAction self) -> SoTextureCoordinateBinding::Binding"},
	 { "SoCallbackAction_getTextureBlendColor", _wrap_SoCallbackAction_getTextureBlendColor, METH_O, "SoCallbackAction_getTextureBlendColor(SoCallbackAction self) -> SbColor"},
	 { "SoCallbackAction_getTextureImage", _wrap_SoCallbackAction_getTextureImage, METH_VARARGS, "\n"
		"SoCallbackAction_getTextureImage(SoCallbackAction self, SbVec2s size, int & numcomps) -> unsigned char const\n"
		"SoCallbackAction_getTextureImage(SoCallbackAction self, SbVec3s size, int & numcomps) -> unsigned char const *\n"
		""},
	 { "SoCallbackAction_getTextureMatrix", _wrap_SoCallbackAction_getTextureMatrix, METH_O, "SoCallbackAction_getTextureMatrix(SoCallbackAction self) -> SbMatrix"},
	 { "SoCallbackAction_getTextureModel", _wrap_SoCallbackAction_getTextureModel, METH_O, "SoCallbackAction_getTextureModel(SoCallbackAction self) -> SoTexture2::Model"},
	 { "SoCallbackAction_getTextureWrapS", _wrap_SoCallbackAction_getTextureWrapS, METH_O, "SoCallbackAction_getTextureWrapS(SoCallbackAction self) -> SoTexture2::Wrap"},
	 { "SoCallbackAction_getTextureWrapT", _wrap_SoCallbackAction_getTextureWrapT, METH_O, "SoCallbackAction_getTextureWrapT(SoCallbackAction self) -> SoTexture2::Wrap"},
	 { "SoCallbackAction_getTextureWrapR", _wrap_SoCallbackAction_getTextureWrapR, METH_O, "SoCallbackAction_getTextureWrapR(SoCallbackAction self) -> SoTexture2::Wrap"},
	 { "SoCallbackAction_getModelMatrix", _wrap_SoCallbackAction_getModelMatrix, METH_O, "SoCallbackAction_getModelMatrix(SoCallbackAction self) -> SbMatrix"},
	 { "SoCallbackAction_getUnits", _wrap_SoCallbackAction_getUnits, METH_O, "SoCallbackAction_getUnits(SoCallbackAction self) -> SoUnits::Units"},
	 { "SoCallbackAction_getFocalDistance", _wrap_SoCallbackAction_getFocalDistance, METH_O, "SoCallbackAction_getFocalDistance(SoCallbackAction self) -> float"},
	 { "SoCallbackAction_getProjectionMatrix", _wrap_SoCallbackAction_getProjectionMatrix, METH_O, "SoCallbackAction_getProjectionMatrix(SoCallbackAction self) -> SbMatrix"},
	 { "SoCallbackAction_getViewingMatrix", _wrap_SoCallbackAction_getViewingMatrix, METH_O, "SoCallbackAction_getViewingMatrix(SoCallbackAction self) -> SbMatrix"},
	 { "SoCallbackAction_getViewVolume", _wrap_SoCallbackAction_getViewVolume, METH_O, "SoCallbackAction_getViewVolume(SoCallbackAction self) -> SbViewVolume"},
	 { "SoCallbackAction_getViewportRegion", _wrap_SoCallbackAction_getViewportRegion, METH_O, "SoCallbackAction_getViewportRegion(SoCallbackAction self) -> SbViewportRegion"},
	 { "SoCallbackAction_getPickStyle", _wrap_SoCallbackAction_getPickStyle, METH_O, "SoCallbackAction_getPickStyle(SoCallbackAction self) -> SoPickStyle::Style"},
	 { "SoCallbackAction_getSwitch", _wrap_SoCallbackAction_getSwitch, METH_O, "SoCallbackAction_getSwitch(SoCallbackAction self) -> int32_t"},
	 { "SoCallbackAction_getCurrentResponse", _wrap_SoCallbackAction_getCurrentResponse, METH_O, "SoCallbackAction_getCurrentResponse(SoCallbackAction self) -> SoCallbackAction::Response"},
	 { "SoCallbackAction_invokePreCallbacks", _wrap_SoCallbackAction_invokePreCallbacks, METH_VARARGS, "SoCallbackAction_invokePreCallbacks(SoCallbackAction self, SoNode node)"},
	 { "SoCallbackAction_invokePostCallbacks", _wrap_SoCallbackAction_invokePostCallbacks, METH_VARARGS, "SoCallbackAction_invokePostCallbacks(SoCallbackAction self, SoNode node)"},
	 { "SoCallbackAction_invokeTriangleCallbacks", _wrap_SoCallbackAction_invokeTriangleCallbacks, METH_VARARGS, "SoCallbackAction_invokeTriangleCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2, SoPrimitiveVertex v3)"},
	 { "SoCallbackAction_invokeLineSegmentCallbacks", _wrap_SoCallbackAction_invokeLineSegmentCallbacks, METH_VARARGS, "SoCallbackAction_invokeLineSegmentCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"},
	 { "SoCallbackAction_invokePointCallbacks", _wrap_SoCallbackAction_invokePointCallbacks, METH_VARARGS, "SoCallbackAction_invokePointCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v)"},
	 { "SoCallbackAction_shouldGeneratePrimitives", _wrap_SoCallbackAction_shouldGeneratePrimitives, METH_VARARGS, "SoCallbackAction_shouldGeneratePrimitives(SoCallbackAction self, SoShape shape) -> SbBool"},
	 { "SoCallbackAction_getCurPathTail", _wrap_SoCallbackAction_getCurPathTail, METH_O, "SoCallbackAction_getCurPathTail(SoCallbackAction self) -> SoNode"},
	 { "SoCallbackAction_setCurrentNode", _wrap_SoCallbackAction_setCurrentNode, METH_VARARGS, "SoCallbackAction_setCurrentNode(SoCallbackAction self, SoNode node)"},
	 { "SoCallbackAction_setCallbackAll", _wrap_SoCallbackAction_setCallbackAll, METH_VARARGS, "SoCallbackAction_setCallbackAll(SoCallbackAction self, SbBool callbackall)"},
	 { "SoCallbackAction_isCallbackAll", _wrap_SoCallbackAction_isCallbackAll, METH_O, "SoCallbackAction_isCallbackAll(SoCallbackAction self) -> SbBool"},
	 { "SoCallbackAction_getMaterial", _wrap_SoCallbackAction_getMaterial, METH_VARARGS, "SoCallbackAction_getMaterial(SoCallbackAction self, int const index=0) -> PyObject"},
	 { "SoCallbackAction_addPreCallback", _wrap_SoCallbackAction_addPreCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addPreCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)\n"
		"SoCallbackAction_addPreCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addPostCallback", _wrap_SoCallbackAction_addPostCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addPostCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)\n"
		"SoCallbackAction_addPostCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addPreTailCallback", _wrap_SoCallbackAction_addPreTailCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addPreTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)\n"
		"SoCallbackAction_addPreTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addPostTailCallback", _wrap_SoCallbackAction_addPostTailCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addPostTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)\n"
		"SoCallbackAction_addPostTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addTriangleCallback", _wrap_SoCallbackAction_addTriangleCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addTriangleCallback(SoCallbackAction self, SoType type, SoTriangleCB * cb, void * userdata)\n"
		"SoCallbackAction_addTriangleCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addLineSegmentCallback", _wrap_SoCallbackAction_addLineSegmentCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addLineSegmentCallback(SoCallbackAction self, SoType type, SoLineSegmentCB * cb, void * userdata)\n"
		"SoCallbackAction_addLineSegmentCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_addPointCallback", _wrap_SoCallbackAction_addPointCallback, METH_VARARGS, "\n"
		"SoCallbackAction_addPointCallback(SoCallbackAction self, SoType type, SoPointCB * cb, void * userdata)\n"
		"SoCallbackAction_addPointCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoCallbackAction_swigregister", SoCallbackAction_swigregister, METH_O, NULL},
	 { "SoCallbackAction_swiginit", SoCallbackAction_swiginit, METH_VARARGS, NULL},
	 { "new_SbViewportRegion", _wrap_new_SbViewportRegion, METH_VARARGS, "\n"
		"SbViewportRegion()\n"
		"SbViewportRegion(short width, short height)\n"
		"SbViewportRegion(SbVec2s winSize)\n"
		"new_SbViewportRegion(SbViewportRegion vpReg) -> SbViewportRegion\n"
		""},
	 { "SbViewportRegion_setWindowSize", _wrap_SbViewportRegion_setWindowSize, METH_VARARGS, "\n"
		"SbViewportRegion_setWindowSize(SbViewportRegion self, short width, short height)\n"
		"SbViewportRegion_setWindowSize(SbViewportRegion self, SbVec2s winSize)\n"
		""},
	 { "SbViewportRegion_setViewport", _wrap_SbViewportRegion_setViewport, METH_VARARGS, "\n"
		"SbViewportRegion_setViewport(SbViewportRegion self, float left, float bottom, float width, float height)\n"
		"SbViewportRegion_setViewport(SbViewportRegion self, SbVec2f origin, SbVec2f size)\n"
		""},
	 { "SbViewportRegion_setViewportPixels", _wrap_SbViewportRegion_setViewportPixels, METH_VARARGS, "\n"
		"SbViewportRegion_setViewportPixels(SbViewportRegion self, short left, short bottom, short width, short height)\n"
		"SbViewportRegion_setViewportPixels(SbViewportRegion self, SbVec2s origin, SbVec2s size)\n"
		""},
	 { "SbViewportRegion_getWindowSize", _wrap_SbViewportRegion_getWindowSize, METH_O, "SbViewportRegion_getWindowSize(SbViewportRegion self) -> SbVec2s"},
	 { "SbViewportRegion_getViewportOrigin", _wrap_SbViewportRegion_getViewportOrigin, METH_O, "SbViewportRegion_getViewportOrigin(SbViewportRegion self) -> SbVec2f"},
	 { "SbViewportRegion_getViewportOriginPixels", _wrap_SbViewportRegion_getViewportOriginPixels, METH_O, "SbViewportRegion_getViewportOriginPixels(SbViewportRegion self) -> SbVec2s"},
	 { "SbViewportRegion_getViewportSize", _wrap_SbViewportRegion_getViewportSize, METH_O, "SbViewportRegion_getViewportSize(SbViewportRegion self) -> SbVec2f"},
	 { "SbViewportRegion_getViewportSizePixels", _wrap_SbViewportRegion_getViewportSizePixels, METH_O, "SbViewportRegion_getViewportSizePixels(SbViewportRegion self) -> SbVec2s"},
	 { "SbViewportRegion_getViewportAspectRatio", _wrap_SbViewportRegion_getViewportAspectRatio, METH_O, "SbViewportRegion_getViewportAspectRatio(SbViewportRegion self) -> float"},
	 { "SbViewportRegion_scaleWidth", _wrap_SbViewportRegion_scaleWidth, METH_VARARGS, "SbViewportRegion_scaleWidth(SbViewportRegion self, float ratio)"},
	 { "SbViewportRegion_scaleHeight", _wrap_SbViewportRegion_scaleHeight, METH_VARARGS, "SbViewportRegion_scaleHeight(SbViewportRegion self, float ratio)"},
	 { "SbViewportRegion_setPixelsPerInch", _wrap_SbViewportRegion_setPixelsPerInch, METH_VARARGS, "SbViewportRegion_setPixelsPerInch(SbViewportRegion self, float ppi)"},
	 { "SbViewportRegion_getPixelsPerInch", _wrap_SbViewportRegion_getPixelsPerInch, METH_O, "SbViewportRegion_getPixelsPerInch(SbViewportRegion self) -> float"},
	 { "SbViewportRegion_getPixelsPerPoint", _wrap_SbViewportRegion_getPixelsPerPoint, METH_O, "SbViewportRegion_getPixelsPerPoint(SbViewportRegion self) -> float"},
	 { "SbViewportRegion_output", _wrap_SbViewportRegion_output, METH_VARARGS, "SbViewportRegion_output(SbViewportRegion self, FILE * file)"},
	 { "SbViewportRegion___eq__", _wrap_SbViewportRegion___eq__, METH_VARARGS, "SbViewportRegion___eq__(SbViewportRegion self, SbViewportRegion u) -> int"},
	 { "SbViewportRegion___ne__", _wrap_SbViewportRegion___ne__, METH_VARARGS, "SbViewportRegion___ne__(SbViewportRegion self, SbViewportRegion u) -> int"},
	 { "delete_SbViewportRegion", _wrap_delete_SbViewportRegion, METH_O, "delete_SbViewportRegion(SbViewportRegion self)"},
	 { "SbViewportRegion_swigregister", SbViewportRegion_swigregister, METH_O, NULL},
	 { "SbViewportRegion_swiginit", SbViewportRegion_swiginit, METH_VARARGS, NULL},
	 { "SoGLRenderAction_getTypeId", _wrap_SoGLRenderAction_getTypeId, METH_O, "SoGLRenderAction_getTypeId(SoGLRenderAction self) -> SoType"},
	 { "SoGLRenderAction_getClassTypeId", _wrap_SoGLRenderAction_getClassTypeId, METH_NOARGS, "SoGLRenderAction_getClassTypeId() -> SoType"},
	 { "SoGLRenderAction_addMethod", _wrap_SoGLRenderAction_addMethod, METH_VARARGS, "SoGLRenderAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoGLRenderAction_enableElement", _wrap_SoGLRenderAction_enableElement, METH_VARARGS, "SoGLRenderAction_enableElement(SoType type, int const stackindex)"},
	 { "SoGLRenderAction_initClass", _wrap_SoGLRenderAction_initClass, METH_NOARGS, "SoGLRenderAction_initClass()"},
	 { "new_SoGLRenderAction", _wrap_new_SoGLRenderAction, METH_O, "new_SoGLRenderAction(SbViewportRegion viewportregion) -> SoGLRenderAction"},
	 { "delete_SoGLRenderAction", _wrap_delete_SoGLRenderAction, METH_O, "delete_SoGLRenderAction(SoGLRenderAction self)"},
	 { "SoGLRenderAction_setViewportRegion", _wrap_SoGLRenderAction_setViewportRegion, METH_VARARGS, "SoGLRenderAction_setViewportRegion(SoGLRenderAction self, SbViewportRegion newregion)"},
	 { "SoGLRenderAction_getViewportRegion", _wrap_SoGLRenderAction_getViewportRegion, METH_O, "SoGLRenderAction_getViewportRegion(SoGLRenderAction self) -> SbViewportRegion"},
	 { "SoGLRenderAction_setUpdateArea", _wrap_SoGLRenderAction_setUpdateArea, METH_VARARGS, "SoGLRenderAction_setUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"},
	 { "SoGLRenderAction_getUpdateArea", _wrap_SoGLRenderAction_getUpdateArea, METH_VARARGS, "SoGLRenderAction_getUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"},
	 { "SoGLRenderAction_getAbortCallback", _wrap_SoGLRenderAction_getAbortCallback, METH_VARARGS, "SoGLRenderAction_getAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *& func_out, void *& userdata_out)"},
	 { "SoGLRenderAction_setTransparencyType", _wrap_SoGLRenderAction_setTransparencyType, METH_VARARGS, "SoGLRenderAction_setTransparencyType(SoGLRenderAction self, SoGLRenderAction::TransparencyType const type)"},
	 { "SoGLRenderAction_getTransparencyType", _wrap_SoGLRenderAction_getTransparencyType, METH_O, "SoGLRenderAction_getTransparencyType(SoGLRenderAction self) -> SoGLRenderAction::TransparencyType"},
	 { "SoGLRenderAction_setTransparentDelayedObjectRenderType", _wrap_SoGLRenderAction_setTransparentDelayedObjectRenderType, METH_VARARGS, "SoGLRenderAction_setTransparentDelayedObjectRenderType(SoGLRenderAction self, SoGLRenderAction::TransparentDelayedObjectRenderType type)"},
	 { "SoGLRenderAction_getTransparentDelayedObjectRenderType", _wrap_SoGLRenderAction_getTransparentDelayedObjectRenderType, METH_O, "SoGLRenderAction_getTransparentDelayedObjectRenderType(SoGLRenderAction self) -> SoGLRenderAction::TransparentDelayedObjectRenderType"},
	 { "SoGLRenderAction_setSmoothing", _wrap_SoGLRenderAction_setSmoothing, METH_VARARGS, "SoGLRenderAction_setSmoothing(SoGLRenderAction self, SbBool const smooth)"},
	 { "SoGLRenderAction_isSmoothing", _wrap_SoGLRenderAction_isSmoothing, METH_O, "SoGLRenderAction_isSmoothing(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_setNumPasses", _wrap_SoGLRenderAction_setNumPasses, METH_VARARGS, "SoGLRenderAction_setNumPasses(SoGLRenderAction self, int const num)"},
	 { "SoGLRenderAction_getNumPasses", _wrap_SoGLRenderAction_getNumPasses, METH_O, "SoGLRenderAction_getNumPasses(SoGLRenderAction self) -> int"},
	 { "SoGLRenderAction_setPassUpdate", _wrap_SoGLRenderAction_setPassUpdate, METH_VARARGS, "SoGLRenderAction_setPassUpdate(SoGLRenderAction self, SbBool const flag)"},
	 { "SoGLRenderAction_isPassUpdate", _wrap_SoGLRenderAction_isPassUpdate, METH_O, "SoGLRenderAction_isPassUpdate(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_setCacheContext", _wrap_SoGLRenderAction_setCacheContext, METH_VARARGS, "SoGLRenderAction_setCacheContext(SoGLRenderAction self, uint32_t const context)"},
	 { "SoGLRenderAction_getCacheContext", _wrap_SoGLRenderAction_getCacheContext, METH_O, "SoGLRenderAction_getCacheContext(SoGLRenderAction self) -> uint32_t"},
	 { "SoGLRenderAction_addDelayedPath", _wrap_SoGLRenderAction_addDelayedPath, METH_VARARGS, "SoGLRenderAction_addDelayedPath(SoGLRenderAction self, SoPath path)"},
	 { "SoGLRenderAction_isRenderingDelayedPaths", _wrap_SoGLRenderAction_isRenderingDelayedPaths, METH_O, "SoGLRenderAction_isRenderingDelayedPaths(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_handleTransparency", _wrap_SoGLRenderAction_handleTransparency, METH_VARARGS, "SoGLRenderAction_handleTransparency(SoGLRenderAction self, SbBool istransparent=0) -> SbBool"},
	 { "SoGLRenderAction_setCurPass", _wrap_SoGLRenderAction_setCurPass, METH_VARARGS, "SoGLRenderAction_setCurPass(SoGLRenderAction self, int const passnum, int const numpasses)"},
	 { "SoGLRenderAction_getCurPass", _wrap_SoGLRenderAction_getCurPass, METH_O, "SoGLRenderAction_getCurPass(SoGLRenderAction self) -> int"},
	 { "SoGLRenderAction_abortNow", _wrap_SoGLRenderAction_abortNow, METH_O, "SoGLRenderAction_abortNow(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_setRenderingIsRemote", _wrap_SoGLRenderAction_setRenderingIsRemote, METH_VARARGS, "SoGLRenderAction_setRenderingIsRemote(SoGLRenderAction self, SbBool isremote)"},
	 { "SoGLRenderAction_getRenderingIsRemote", _wrap_SoGLRenderAction_getRenderingIsRemote, METH_O, "SoGLRenderAction_getRenderingIsRemote(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_invalidateState", _wrap_SoGLRenderAction_invalidateState, METH_O, "SoGLRenderAction_invalidateState(SoGLRenderAction self)"},
	 { "SoGLRenderAction_setSortedLayersNumPasses", _wrap_SoGLRenderAction_setSortedLayersNumPasses, METH_VARARGS, "SoGLRenderAction_setSortedLayersNumPasses(SoGLRenderAction self, int num)"},
	 { "SoGLRenderAction_getSortedLayersNumPasses", _wrap_SoGLRenderAction_getSortedLayersNumPasses, METH_O, "SoGLRenderAction_getSortedLayersNumPasses(SoGLRenderAction self) -> int"},
	 { "SoGLRenderAction_setSortedObjectOrderStrategy", _wrap_SoGLRenderAction_setSortedObjectOrderStrategy, METH_VARARGS, "SoGLRenderAction_setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None, void * closure=None)"},
	 { "SoGLRenderAction_setDelayedObjDepthWrite", _wrap_SoGLRenderAction_setDelayedObjDepthWrite, METH_VARARGS, "SoGLRenderAction_setDelayedObjDepthWrite(SoGLRenderAction self, SbBool write)"},
	 { "SoGLRenderAction_getDelayedObjDepthWrite", _wrap_SoGLRenderAction_getDelayedObjDepthWrite, METH_O, "SoGLRenderAction_getDelayedObjDepthWrite(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_isRenderingTranspPaths", _wrap_SoGLRenderAction_isRenderingTranspPaths, METH_O, "SoGLRenderAction_isRenderingTranspPaths(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_isRenderingTranspBackfaces", _wrap_SoGLRenderAction_isRenderingTranspBackfaces, METH_O, "SoGLRenderAction_isRenderingTranspBackfaces(SoGLRenderAction self) -> SbBool"},
	 { "SoGLRenderAction_setPassCallback", _wrap_SoGLRenderAction_setPassCallback, METH_VARARGS, "\n"
		"SoGLRenderAction_setPassCallback(SoGLRenderAction self, SoGLRenderPassCB *const func, void *const userdata)\n"
		"SoGLRenderAction_setPassCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoGLRenderAction_setAbortCallback", _wrap_SoGLRenderAction_setAbortCallback, METH_VARARGS, "\n"
		"SoGLRenderAction_setAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *const func, void *const userdata)\n"
		"SoGLRenderAction_setAbortCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoGLRenderAction_addPreRenderCallback", _wrap_SoGLRenderAction_addPreRenderCallback, METH_VARARGS, "\n"
		"SoGLRenderAction_addPreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)\n"
		"SoGLRenderAction_addPreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoGLRenderAction_removePreRenderCallback", _wrap_SoGLRenderAction_removePreRenderCallback, METH_VARARGS, "\n"
		"SoGLRenderAction_removePreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)\n"
		"SoGLRenderAction_removePreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "SoGLRenderAction_constructFromAction", _wrap_SoGLRenderAction_constructFromAction, METH_O, "SoGLRenderAction_constructFromAction(SoAction action) -> SoGLRenderAction"},
	 { "SoGLRenderAction_swigregister", SoGLRenderAction_swigregister, METH_O, NULL},
	 { "SoGLRenderAction_swiginit", SoGLRenderAction_swiginit, METH_VARARGS, NULL},
	 { "SoBoxHighlightRenderAction_getTypeId", _wrap_SoBoxHighlightRenderAction_getTypeId, METH_O, "SoBoxHighlightRenderAction_getTypeId(SoBoxHighlightRenderAction self) -> SoType"},
	 { "SoBoxHighlightRenderAction_getClassTypeId", _wrap_SoBoxHighlightRenderAction_getClassTypeId, METH_NOARGS, "SoBoxHighlightRenderAction_getClassTypeId() -> SoType"},
	 { "SoBoxHighlightRenderAction_addMethod", _wrap_SoBoxHighlightRenderAction_addMethod, METH_VARARGS, "SoBoxHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoBoxHighlightRenderAction_enableElement", _wrap_SoBoxHighlightRenderAction_enableElement, METH_VARARGS, "SoBoxHighlightRenderAction_enableElement(SoType type, int const stackindex)"},
	 { "SoBoxHighlightRenderAction_initClass", _wrap_SoBoxHighlightRenderAction_initClass, METH_NOARGS, "SoBoxHighlightRenderAction_initClass()"},
	 { "new_SoBoxHighlightRenderAction", _wrap_new_SoBoxHighlightRenderAction, METH_VARARGS, "\n"
		"SoBoxHighlightRenderAction()\n"
		"new_SoBoxHighlightRenderAction(SbViewportRegion viewportregion) -> SoBoxHighlightRenderAction\n"
		""},
	 { "delete_SoBoxHighlightRenderAction", _wrap_delete_SoBoxHighlightRenderAction, METH_O, "delete_SoBoxHighlightRenderAction(SoBoxHighlightRenderAction self)"},
	 { "SoBoxHighlightRenderAction_apply", _wrap_SoBoxHighlightRenderAction_apply, METH_VARARGS, "\n"
		"SoBoxHighlightRenderAction_apply(SoBoxHighlightRenderAction self, SoNode node)\n"
		"SoBoxHighlightRenderAction_apply(SoBoxHighlightRenderAction self, SoPath path)\n"
		"SoBoxHighlightRenderAction_apply(SoBoxHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoBoxHighlightRenderAction_setVisible", _wrap_SoBoxHighlightRenderAction_setVisible, METH_VARARGS, "SoBoxHighlightRenderAction_setVisible(SoBoxHighlightRenderAction self, SbBool const visible)"},
	 { "SoBoxHighlightRenderAction_isVisible", _wrap_SoBoxHighlightRenderAction_isVisible, METH_O, "SoBoxHighlightRenderAction_isVisible(SoBoxHighlightRenderAction self) -> SbBool"},
	 { "SoBoxHighlightRenderAction_setColor", _wrap_SoBoxHighlightRenderAction_setColor, METH_VARARGS, "SoBoxHighlightRenderAction_setColor(SoBoxHighlightRenderAction self, SbColor color)"},
	 { "SoBoxHighlightRenderAction_getColor", _wrap_SoBoxHighlightRenderAction_getColor, METH_O, "SoBoxHighlightRenderAction_getColor(SoBoxHighlightRenderAction self) -> SbColor"},
	 { "SoBoxHighlightRenderAction_setLinePattern", _wrap_SoBoxHighlightRenderAction_setLinePattern, METH_VARARGS, "SoBoxHighlightRenderAction_setLinePattern(SoBoxHighlightRenderAction self, unsigned short pattern)"},
	 { "SoBoxHighlightRenderAction_getLinePattern", _wrap_SoBoxHighlightRenderAction_getLinePattern, METH_O, "SoBoxHighlightRenderAction_getLinePattern(SoBoxHighlightRenderAction self) -> unsigned short"},
	 { "SoBoxHighlightRenderAction_setLineWidth", _wrap_SoBoxHighlightRenderAction_setLineWidth, METH_VARARGS, "SoBoxHighlightRenderAction_setLineWidth(SoBoxHighlightRenderAction self, float const width)"},
	 { "SoBoxHighlightRenderAction_getLineWidth", _wrap_SoBoxHighlightRenderAction_getLineWidth, METH_O, "SoBoxHighlightRenderAction_getLineWidth(SoBoxHighlightRenderAction self) -> float"},
	 { "SoBoxHighlightRenderAction_swigregister", SoBoxHighlightRenderAction_swigregister, METH_O, NULL},
	 { "SoBoxHighlightRenderAction_swiginit", SoBoxHighlightRenderAction_swiginit, METH_VARARGS, NULL},
	 { "SoLineHighlightRenderAction_getTypeId", _wrap_SoLineHighlightRenderAction_getTypeId, METH_O, "SoLineHighlightRenderAction_getTypeId(SoLineHighlightRenderAction self) -> SoType"},
	 { "SoLineHighlightRenderAction_getClassTypeId", _wrap_SoLineHighlightRenderAction_getClassTypeId, METH_NOARGS, "SoLineHighlightRenderAction_getClassTypeId() -> SoType"},
	 { "SoLineHighlightRenderAction_addMethod", _wrap_SoLineHighlightRenderAction_addMethod, METH_VARARGS, "SoLineHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoLineHighlightRenderAction_enableElement", _wrap_SoLineHighlightRenderAction_enableElement, METH_VARARGS, "SoLineHighlightRenderAction_enableElement(SoType type, int const stackindex)"},
	 { "SoLineHighlightRenderAction_initClass", _wrap_SoLineHighlightRenderAction_initClass, METH_NOARGS, "SoLineHighlightRenderAction_initClass()"},
	 { "new_SoLineHighlightRenderAction", _wrap_new_SoLineHighlightRenderAction, METH_VARARGS, "\n"
		"SoLineHighlightRenderAction()\n"
		"new_SoLineHighlightRenderAction(SbViewportRegion viewportregion) -> SoLineHighlightRenderAction\n"
		""},
	 { "delete_SoLineHighlightRenderAction", _wrap_delete_SoLineHighlightRenderAction, METH_O, "delete_SoLineHighlightRenderAction(SoLineHighlightRenderAction self)"},
	 { "SoLineHighlightRenderAction_apply", _wrap_SoLineHighlightRenderAction_apply, METH_VARARGS, "\n"
		"SoLineHighlightRenderAction_apply(SoLineHighlightRenderAction self, SoNode node)\n"
		"SoLineHighlightRenderAction_apply(SoLineHighlightRenderAction self, SoPath path)\n"
		"SoLineHighlightRenderAction_apply(SoLineHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoLineHighlightRenderAction_setVisible", _wrap_SoLineHighlightRenderAction_setVisible, METH_VARARGS, "SoLineHighlightRenderAction_setVisible(SoLineHighlightRenderAction self, SbBool const visible)"},
	 { "SoLineHighlightRenderAction_isVisible", _wrap_SoLineHighlightRenderAction_isVisible, METH_O, "SoLineHighlightRenderAction_isVisible(SoLineHighlightRenderAction self) -> SbBool"},
	 { "SoLineHighlightRenderAction_setColor", _wrap_SoLineHighlightRenderAction_setColor, METH_VARARGS, "SoLineHighlightRenderAction_setColor(SoLineHighlightRenderAction self, SbColor color)"},
	 { "SoLineHighlightRenderAction_getColor", _wrap_SoLineHighlightRenderAction_getColor, METH_O, "SoLineHighlightRenderAction_getColor(SoLineHighlightRenderAction self) -> SbColor"},
	 { "SoLineHighlightRenderAction_setLinePattern", _wrap_SoLineHighlightRenderAction_setLinePattern, METH_VARARGS, "SoLineHighlightRenderAction_setLinePattern(SoLineHighlightRenderAction self, uint16_t pattern)"},
	 { "SoLineHighlightRenderAction_getLinePattern", _wrap_SoLineHighlightRenderAction_getLinePattern, METH_O, "SoLineHighlightRenderAction_getLinePattern(SoLineHighlightRenderAction self) -> uint16_t"},
	 { "SoLineHighlightRenderAction_setLineWidth", _wrap_SoLineHighlightRenderAction_setLineWidth, METH_VARARGS, "SoLineHighlightRenderAction_setLineWidth(SoLineHighlightRenderAction self, float const width)"},
	 { "SoLineHighlightRenderAction_getLineWidth", _wrap_SoLineHighlightRenderAction_getLineWidth, METH_O, "SoLineHighlightRenderAction_getLineWidth(SoLineHighlightRenderAction self) -> float"},
	 { "SoLineHighlightRenderAction_swigregister", SoLineHighlightRenderAction_swigregister, METH_O, NULL},
	 { "SoLineHighlightRenderAction_swiginit", SoLineHighlightRenderAction_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox3f", _wrap_new_SbBox3f, METH_VARARGS, "\n"
		"SbBox3f()\n"
		"SbBox3f(float xmin, float ymin, float zmin, float xmax, float ymax, float zmax)\n"
		"SbBox3f(SbVec3f minpoint, SbVec3f maxpoint)\n"
		"SbBox3f(SbBox3d box)\n"
		"SbBox3f(SbBox3s box)\n"
		"new_SbBox3f(SbBox3i32 box) -> SbBox3f\n"
		""},
	 { "SbBox3f_setBounds", _wrap_SbBox3f_setBounds, METH_VARARGS, "\n"
		"SbBox3f_setBounds(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f\n"
		"SbBox3f_setBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f\n"
		"SbBox3f_setBounds(SbBox3f self, SbBox3d box) -> SbBox3f\n"
		"SbBox3f_setBounds(SbBox3f self, SbBox3s box) -> SbBox3f\n"
		"SbBox3f_setBounds(SbBox3f self, SbBox3i32 box) -> SbBox3f\n"
		""},
	 { "SbBox3f_getBounds", _wrap_SbBox3f_getBounds, METH_VARARGS, "\n"
		"SbBox3f_getBounds(SbBox3f self, float & xmin, float & ymin, float & zmin, float & xmax, float & ymax, float & zmax)\n"
		"SbBox3f_getBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint)\n"
		""},
	 { "SbBox3f_getMin", _wrap_SbBox3f_getMin, METH_VARARGS, "\n"
		"SbBox3f_getMin(SbBox3f self) -> SbVec3f\n"
		"SbBox3f_getMin(SbBox3f self) -> SbVec3f\n"
		""},
	 { "SbBox3f_getMax", _wrap_SbBox3f_getMax, METH_VARARGS, "\n"
		"SbBox3f_getMax(SbBox3f self) -> SbVec3f\n"
		"SbBox3f_getMax(SbBox3f self) -> SbVec3f\n"
		""},
	 { "SbBox3f_extendBy", _wrap_SbBox3f_extendBy, METH_VARARGS, "\n"
		"SbBox3f_extendBy(SbBox3f self, SbVec3f pt)\n"
		"SbBox3f_extendBy(SbBox3f self, SbBox3f box)\n"
		""},
	 { "SbBox3f_transform", _wrap_SbBox3f_transform, METH_VARARGS, "SbBox3f_transform(SbBox3f self, SbMatrix matrix)"},
	 { "SbBox3f_makeEmpty", _wrap_SbBox3f_makeEmpty, METH_O, "SbBox3f_makeEmpty(SbBox3f self)"},
	 { "SbBox3f_isEmpty", _wrap_SbBox3f_isEmpty, METH_O, "SbBox3f_isEmpty(SbBox3f self) -> SbBool"},
	 { "SbBox3f_hasVolume", _wrap_SbBox3f_hasVolume, METH_O, "SbBox3f_hasVolume(SbBox3f self) -> SbBool"},
	 { "SbBox3f_getVolume", _wrap_SbBox3f_getVolume, METH_O, "SbBox3f_getVolume(SbBox3f self) -> float"},
	 { "SbBox3f_intersect", _wrap_SbBox3f_intersect, METH_VARARGS, "\n"
		"SbBox3f_intersect(SbBox3f self, SbVec3f pt) -> SbBool\n"
		"SbBox3f_intersect(SbBox3f self, SbBox3f box) -> SbBool\n"
		""},
	 { "SbBox3f_getClosestPoint", _wrap_SbBox3f_getClosestPoint, METH_VARARGS, "SbBox3f_getClosestPoint(SbBox3f self, SbVec3f point) -> SbVec3f"},
	 { "SbBox3f_outside", _wrap_SbBox3f_outside, METH_VARARGS, "SbBox3f_outside(SbBox3f self, SbMatrix mvp, int & cullbits) -> SbBool"},
	 { "SbBox3f_getCenter", _wrap_SbBox3f_getCenter, METH_O, "SbBox3f_getCenter(SbBox3f self) -> SbVec3f"},
	 { "SbBox3f_getOrigin", _wrap_SbBox3f_getOrigin, METH_VARARGS, "SbBox3f_getOrigin(SbBox3f self, float & originX, float & originY, float & originZ)"},
	 { "SbBox3f_getSize", _wrap_SbBox3f_getSize, METH_VARARGS, "\n"
		"SbBox3f_getSize(SbBox3f self, float & sizeX, float & sizeY, float & sizeZ)\n"
		"SbBox3f_getSize(SbBox3f self) -> SbVec3f\n"
		""},
	 { "SbBox3f_getSpan", _wrap_SbBox3f_getSpan, METH_VARARGS, "SbBox3f_getSpan(SbBox3f self, SbVec3f dir, float & dmin, float & dmax)"},
	 { "SbBox3f_output", _wrap_SbBox3f_output, METH_VARARGS, "SbBox3f_output(SbBox3f self, FILE * file)"},
	 { "SbBox3f___eq__", _wrap_SbBox3f___eq__, METH_VARARGS, "SbBox3f___eq__(SbBox3f self, SbBox3f u) -> int"},
	 { "SbBox3f___ne__", _wrap_SbBox3f___ne__, METH_VARARGS, "SbBox3f___ne__(SbBox3f self, SbBox3f u) -> int"},
	 { "delete_SbBox3f", _wrap_delete_SbBox3f, METH_O, "delete_SbBox3f(SbBox3f self)"},
	 { "SbBox3f_swigregister", SbBox3f_swigregister, METH_O, NULL},
	 { "SbBox3f_swiginit", SbBox3f_swiginit, METH_VARARGS, NULL},
	 { "new_SbMatrix", _wrap_new_SbMatrix, METH_VARARGS, "\n"
		"SbMatrix()\n"
		"SbMatrix(float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)\n"
		"SbMatrix(SbMat const & matrix)\n"
		"SbMatrix(SbMat const * matrix)\n"
		"new_SbMatrix(SbDPMatrix matrix) -> SbMatrix\n"
		""},
	 { "delete_SbMatrix", _wrap_delete_SbMatrix, METH_O, "delete_SbMatrix(SbMatrix self)"},
	 { "SbMatrix_setValue", _wrap_SbMatrix_setValue, METH_VARARGS, "\n"
		"SbMatrix_setValue(SbMatrix self, SbMat const & m)\n"
		"SbMatrix_setValue(SbMatrix self, SbDPMatrix m)\n"
		"SbMatrix_setValue(SbMatrix self, float const * pMat)\n"
		""},
	 { "SbMatrix_makeIdentity", _wrap_SbMatrix_makeIdentity, METH_O, "SbMatrix_makeIdentity(SbMatrix self)"},
	 { "SbMatrix_setRotate", _wrap_SbMatrix_setRotate, METH_VARARGS, "SbMatrix_setRotate(SbMatrix self, SbRotation q)"},
	 { "SbMatrix_inverse", _wrap_SbMatrix_inverse, METH_O, "SbMatrix_inverse(SbMatrix self) -> SbMatrix"},
	 { "SbMatrix_det3", _wrap_SbMatrix_det3, METH_VARARGS, "\n"
		"SbMatrix_det3(SbMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> float\n"
		"SbMatrix_det3(SbMatrix self) -> float\n"
		""},
	 { "SbMatrix_det4", _wrap_SbMatrix_det4, METH_O, "SbMatrix_det4(SbMatrix self) -> float"},
	 { "SbMatrix_equals", _wrap_SbMatrix_equals, METH_VARARGS, "SbMatrix_equals(SbMatrix self, SbMatrix m, float tolerance) -> SbBool"},
	 { "SbMatrix_getValue", _wrap_SbMatrix_getValue, METH_VARARGS, "\n"
		"SbMatrix_getValue(SbMatrix self) -> SbMat const\n"
		"SbMatrix_getValue(SbMatrix self, SbMat & m)\n"
		""},
	 { "SbMatrix_identity", _wrap_SbMatrix_identity, METH_NOARGS, "SbMatrix_identity() -> SbMatrix"},
	 { "SbMatrix_setScale", _wrap_SbMatrix_setScale, METH_VARARGS, "\n"
		"SbMatrix_setScale(SbMatrix self, float const s)\n"
		"SbMatrix_setScale(SbMatrix self, SbVec3f s)\n"
		""},
	 { "SbMatrix_setTranslate", _wrap_SbMatrix_setTranslate, METH_VARARGS, "SbMatrix_setTranslate(SbMatrix self, SbVec3f t)"},
	 { "SbMatrix_setTransform", _wrap_SbMatrix_setTransform, METH_VARARGS, "\n"
		"SbMatrix_setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s)\n"
		"SbMatrix_setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)\n"
		"SbMatrix_setTransform(SbMatrix self, SbVec3f translation, SbRotation rotation, SbVec3f scaleFactor, SbRotation scaleOrientation, SbVec3f center)\n"
		""},
	 { "SbMatrix_factor", _wrap_SbMatrix_factor, METH_VARARGS, "SbMatrix_factor(SbMatrix self, SbMatrix r, SbVec3f s, SbMatrix u, SbVec3f t, SbMatrix proj) -> SbBool"},
	 { "SbMatrix_LUDecomposition", _wrap_SbMatrix_LUDecomposition, METH_VARARGS, "SbMatrix_LUDecomposition(SbMatrix self, int [4] index, float & d) -> SbBool"},
	 { "SbMatrix_LUBackSubstitution", _wrap_SbMatrix_LUBackSubstitution, METH_VARARGS, "SbMatrix_LUBackSubstitution(SbMatrix self, int [4] index, float [4] b)"},
	 { "SbMatrix_transpose", _wrap_SbMatrix_transpose, METH_O, "SbMatrix_transpose(SbMatrix self) -> SbMatrix"},
	 { "SbMatrix_multRight", _wrap_SbMatrix_multRight, METH_VARARGS, "SbMatrix_multRight(SbMatrix self, SbMatrix m) -> SbMatrix"},
	 { "SbMatrix_multLeft", _wrap_SbMatrix_multLeft, METH_VARARGS, "SbMatrix_multLeft(SbMatrix self, SbMatrix m) -> SbMatrix"},
	 { "SbMatrix_multMatrixVec", _wrap_SbMatrix_multMatrixVec, METH_VARARGS, "SbMatrix_multMatrixVec(SbMatrix self, SbVec3f src)"},
	 { "SbMatrix_multDirMatrix", _wrap_SbMatrix_multDirMatrix, METH_VARARGS, "SbMatrix_multDirMatrix(SbMatrix self, SbVec3f src)"},
	 { "SbMatrix_multLineMatrix", _wrap_SbMatrix_multLineMatrix, METH_VARARGS, "SbMatrix_multLineMatrix(SbMatrix self, SbLine src, SbLine dst)"},
	 { "SbMatrix_multVecMatrix", _wrap_SbMatrix_multVecMatrix, METH_VARARGS, "\n"
		"SbMatrix_multVecMatrix(SbMatrix self, SbVec3f src)\n"
		"SbMatrix_multVecMatrix(SbMatrix self, SbVec4f src)\n"
		""},
	 { "SbMatrix_output", _wrap_SbMatrix_output, METH_VARARGS, "SbMatrix_output(SbMatrix self, FILE * fp)"},
	 { "SbMatrix___imul__", _wrap_SbMatrix___imul__, METH_VARARGS, "SbMatrix___imul__(SbMatrix self, SbMatrix m) -> SbMatrix"},
	 { "SbMatrix_getTransform", _wrap_SbMatrix_getTransform, METH_VARARGS, "\n"
		"SbMatrix_getTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)\n"
		"SbMatrix_getTransform(SbMatrix self) -> PyObject\n"
		"SbMatrix_getTransform(SbMatrix self, SbVec3f center) -> PyObject *\n"
		""},
	 { "SbMatrix___mul__", _wrap_SbMatrix___mul__, METH_VARARGS, "\n"
		"SbMatrix___mul__(SbMatrix self, SbMatrix u) -> SbMatrix\n"
		"SbMatrix___mul__(SbMatrix self, SbVec3f u) -> SbVec3f\n"
		""},
	 { "SbMatrix___rmul__", _wrap_SbMatrix___rmul__, METH_VARARGS, "SbMatrix___rmul__(SbMatrix self, SbVec3f u) -> SbVec3f"},
	 { "SbMatrix___eq__", _wrap_SbMatrix___eq__, METH_VARARGS, "SbMatrix___eq__(SbMatrix self, SbMatrix u) -> int"},
	 { "SbMatrix___ne__", _wrap_SbMatrix___ne__, METH_VARARGS, "SbMatrix___ne__(SbMatrix self, SbMatrix u) -> int"},
	 { "SbMatrix___getitem__", _wrap_SbMatrix___getitem__, METH_VARARGS, "SbMatrix___getitem__(SbMatrix self, int i) -> float const *"},
	 { "SbMatrix_swigregister", SbMatrix_swigregister, METH_O, NULL},
	 { "SbMatrix_swiginit", SbMatrix_swiginit, METH_VARARGS, NULL},
	 { "new_SbXfBox3f", _wrap_new_SbXfBox3f, METH_VARARGS, "\n"
		"SbXfBox3f()\n"
		"SbXfBox3f(SbVec3f boxmin, SbVec3f boxmax)\n"
		"new_SbXfBox3f(SbBox3f box) -> SbXfBox3f\n"
		""},
	 { "delete_SbXfBox3f", _wrap_delete_SbXfBox3f, METH_O, "delete_SbXfBox3f(SbXfBox3f self)"},
	 { "SbXfBox3f_setTransform", _wrap_SbXfBox3f_setTransform, METH_VARARGS, "SbXfBox3f_setTransform(SbXfBox3f self, SbMatrix m)"},
	 { "SbXfBox3f_getTransform", _wrap_SbXfBox3f_getTransform, METH_O, "SbXfBox3f_getTransform(SbXfBox3f self) -> SbMatrix"},
	 { "SbXfBox3f_getInverse", _wrap_SbXfBox3f_getInverse, METH_O, "SbXfBox3f_getInverse(SbXfBox3f self) -> SbMatrix"},
	 { "SbXfBox3f_getCenter", _wrap_SbXfBox3f_getCenter, METH_O, "SbXfBox3f_getCenter(SbXfBox3f self) -> SbVec3f"},
	 { "SbXfBox3f_extendBy", _wrap_SbXfBox3f_extendBy, METH_VARARGS, "\n"
		"SbXfBox3f_extendBy(SbXfBox3f self, SbVec3f pt)\n"
		"SbXfBox3f_extendBy(SbXfBox3f self, SbBox3f bb)\n"
		"SbXfBox3f_extendBy(SbXfBox3f self, SbXfBox3f bb)\n"
		""},
	 { "SbXfBox3f_intersect", _wrap_SbXfBox3f_intersect, METH_VARARGS, "\n"
		"SbXfBox3f_intersect(SbXfBox3f self, SbVec3f pt) -> SbBool\n"
		"SbXfBox3f_intersect(SbXfBox3f self, SbBox3f bb) -> SbBool\n"
		"SbXfBox3f_intersect(SbXfBox3f self, SbXfBox3f bb) -> SbBool\n"
		""},
	 { "SbXfBox3f_getSpan", _wrap_SbXfBox3f_getSpan, METH_VARARGS, "SbXfBox3f_getSpan(SbXfBox3f self, SbVec3f direction, float & dMin, float & dMax)"},
	 { "SbXfBox3f_project", _wrap_SbXfBox3f_project, METH_O, "SbXfBox3f_project(SbXfBox3f self) -> SbBox3f"},
	 { "SbXfBox3f_transform", _wrap_SbXfBox3f_transform, METH_VARARGS, "SbXfBox3f_transform(SbXfBox3f self, SbMatrix m)"},
	 { "SbXfBox3f_getVolume", _wrap_SbXfBox3f_getVolume, METH_O, "SbXfBox3f_getVolume(SbXfBox3f self) -> float"},
	 { "SbXfBox3f_output", _wrap_SbXfBox3f_output, METH_VARARGS, "SbXfBox3f_output(SbXfBox3f self, FILE * file)"},
	 { "SbXfBox3f___eq__", _wrap_SbXfBox3f___eq__, METH_VARARGS, "SbXfBox3f___eq__(SbXfBox3f self, SbXfBox3f u) -> int"},
	 { "SbXfBox3f___ne__", _wrap_SbXfBox3f___ne__, METH_VARARGS, "SbXfBox3f___ne__(SbXfBox3f self, SbXfBox3f u) -> int"},
	 { "SbXfBox3f_swigregister", SbXfBox3f_swigregister, METH_O, NULL},
	 { "SbXfBox3f_swiginit", SbXfBox3f_swiginit, METH_VARARGS, NULL},
	 { "SoGetBoundingBoxAction_getTypeId", _wrap_SoGetBoundingBoxAction_getTypeId, METH_O, "SoGetBoundingBoxAction_getTypeId(SoGetBoundingBoxAction self) -> SoType"},
	 { "SoGetBoundingBoxAction_getClassTypeId", _wrap_SoGetBoundingBoxAction_getClassTypeId, METH_NOARGS, "SoGetBoundingBoxAction_getClassTypeId() -> SoType"},
	 { "SoGetBoundingBoxAction_addMethod", _wrap_SoGetBoundingBoxAction_addMethod, METH_VARARGS, "SoGetBoundingBoxAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoGetBoundingBoxAction_enableElement", _wrap_SoGetBoundingBoxAction_enableElement, METH_VARARGS, "SoGetBoundingBoxAction_enableElement(SoType type, int const stackindex)"},
	 { "SoGetBoundingBoxAction_initClass", _wrap_SoGetBoundingBoxAction_initClass, METH_NOARGS, "SoGetBoundingBoxAction_initClass()"},
	 { "new_SoGetBoundingBoxAction", _wrap_new_SoGetBoundingBoxAction, METH_O, "new_SoGetBoundingBoxAction(SbViewportRegion vp) -> SoGetBoundingBoxAction"},
	 { "delete_SoGetBoundingBoxAction", _wrap_delete_SoGetBoundingBoxAction, METH_O, "delete_SoGetBoundingBoxAction(SoGetBoundingBoxAction self)"},
	 { "SoGetBoundingBoxAction_setViewportRegion", _wrap_SoGetBoundingBoxAction_setViewportRegion, METH_VARARGS, "SoGetBoundingBoxAction_setViewportRegion(SoGetBoundingBoxAction self, SbViewportRegion newregion)"},
	 { "SoGetBoundingBoxAction_getViewportRegion", _wrap_SoGetBoundingBoxAction_getViewportRegion, METH_O, "SoGetBoundingBoxAction_getViewportRegion(SoGetBoundingBoxAction self) -> SbViewportRegion"},
	 { "SoGetBoundingBoxAction_getBoundingBox", _wrap_SoGetBoundingBoxAction_getBoundingBox, METH_O, "SoGetBoundingBoxAction_getBoundingBox(SoGetBoundingBoxAction self) -> SbBox3f"},
	 { "SoGetBoundingBoxAction_getXfBoundingBox", _wrap_SoGetBoundingBoxAction_getXfBoundingBox, METH_O, "SoGetBoundingBoxAction_getXfBoundingBox(SoGetBoundingBoxAction self) -> SbXfBox3f"},
	 { "SoGetBoundingBoxAction_getCenter", _wrap_SoGetBoundingBoxAction_getCenter, METH_O, "SoGetBoundingBoxAction_getCenter(SoGetBoundingBoxAction self) -> SbVec3f"},
	 { "SoGetBoundingBoxAction_setInCameraSpace", _wrap_SoGetBoundingBoxAction_setInCameraSpace, METH_VARARGS, "SoGetBoundingBoxAction_setInCameraSpace(SoGetBoundingBoxAction self, SbBool const flag)"},
	 { "SoGetBoundingBoxAction_isInCameraSpace", _wrap_SoGetBoundingBoxAction_isInCameraSpace, METH_O, "SoGetBoundingBoxAction_isInCameraSpace(SoGetBoundingBoxAction self) -> SbBool"},
	 { "SoGetBoundingBoxAction_setResetPath", _wrap_SoGetBoundingBoxAction_setResetPath, METH_VARARGS, "SoGetBoundingBoxAction_setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1, SoGetBoundingBoxAction::ResetType const what=ALL)"},
	 { "SoGetBoundingBoxAction_getResetPath", _wrap_SoGetBoundingBoxAction_getResetPath, METH_O, "SoGetBoundingBoxAction_getResetPath(SoGetBoundingBoxAction self) -> SoPath"},
	 { "SoGetBoundingBoxAction_isResetPath", _wrap_SoGetBoundingBoxAction_isResetPath, METH_O, "SoGetBoundingBoxAction_isResetPath(SoGetBoundingBoxAction self) -> SbBool"},
	 { "SoGetBoundingBoxAction_isResetBefore", _wrap_SoGetBoundingBoxAction_isResetBefore, METH_O, "SoGetBoundingBoxAction_isResetBefore(SoGetBoundingBoxAction self) -> SbBool"},
	 { "SoGetBoundingBoxAction_getWhatReset", _wrap_SoGetBoundingBoxAction_getWhatReset, METH_O, "SoGetBoundingBoxAction_getWhatReset(SoGetBoundingBoxAction self) -> SoGetBoundingBoxAction::ResetType"},
	 { "SoGetBoundingBoxAction_checkResetBefore", _wrap_SoGetBoundingBoxAction_checkResetBefore, METH_O, "SoGetBoundingBoxAction_checkResetBefore(SoGetBoundingBoxAction self)"},
	 { "SoGetBoundingBoxAction_checkResetAfter", _wrap_SoGetBoundingBoxAction_checkResetAfter, METH_O, "SoGetBoundingBoxAction_checkResetAfter(SoGetBoundingBoxAction self)"},
	 { "SoGetBoundingBoxAction_extendBy", _wrap_SoGetBoundingBoxAction_extendBy, METH_VARARGS, "\n"
		"SoGetBoundingBoxAction_extendBy(SoGetBoundingBoxAction self, SbBox3f box)\n"
		"SoGetBoundingBoxAction_extendBy(SoGetBoundingBoxAction self, SbXfBox3f box)\n"
		""},
	 { "SoGetBoundingBoxAction_setCenter", _wrap_SoGetBoundingBoxAction_setCenter, METH_VARARGS, "SoGetBoundingBoxAction_setCenter(SoGetBoundingBoxAction self, SbVec3f center, SbBool const transformcenter)"},
	 { "SoGetBoundingBoxAction_isCenterSet", _wrap_SoGetBoundingBoxAction_isCenterSet, METH_O, "SoGetBoundingBoxAction_isCenterSet(SoGetBoundingBoxAction self) -> SbBool"},
	 { "SoGetBoundingBoxAction_resetCenter", _wrap_SoGetBoundingBoxAction_resetCenter, METH_O, "SoGetBoundingBoxAction_resetCenter(SoGetBoundingBoxAction self)"},
	 { "SoGetBoundingBoxAction_swigregister", SoGetBoundingBoxAction_swigregister, METH_O, NULL},
	 { "SoGetBoundingBoxAction_swiginit", SoGetBoundingBoxAction_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4f", _wrap_new_SbVec4f, METH_VARARGS, "\n"
		"SbVec4f()\n"
		"SbVec4f(float const [4] v)\n"
		"SbVec4f(float x, float y, float z, float w)\n"
		"SbVec4f(SbVec4d v)\n"
		"SbVec4f(SbVec4b v)\n"
		"SbVec4f(SbVec4s v)\n"
		"new_SbVec4f(SbVec4i32 v) -> SbVec4f\n"
		""},
	 { "SbVec4f_setValue", _wrap_SbVec4f_setValue, METH_VARARGS, "\n"
		"SbVec4f_setValue(SbVec4f self, float const [4] v) -> SbVec4f\n"
		"SbVec4f_setValue(SbVec4f self, float x, float y, float z, float w) -> SbVec4f\n"
		"SbVec4f_setValue(SbVec4f self, SbVec4d v) -> SbVec4f\n"
		"SbVec4f_setValue(SbVec4f self, SbVec4b v) -> SbVec4f\n"
		"SbVec4f_setValue(SbVec4f self, SbVec4s v) -> SbVec4f\n"
		"SbVec4f_setValue(SbVec4f self, SbVec4i32 v) -> SbVec4f\n"
		""},
	 { "SbVec4f_getValue", _wrap_SbVec4f_getValue, METH_O, "SbVec4f_getValue(SbVec4f self) -> float const *"},
	 { "SbVec4f_equals", _wrap_SbVec4f_equals, METH_VARARGS, "SbVec4f_equals(SbVec4f self, SbVec4f v, float tolerance) -> SbBool"},
	 { "SbVec4f_dot", _wrap_SbVec4f_dot, METH_VARARGS, "SbVec4f_dot(SbVec4f self, SbVec4f v) -> float"},
	 { "SbVec4f_getReal", _wrap_SbVec4f_getReal, METH_VARARGS, "SbVec4f_getReal(SbVec4f self, SbVec3f v)"},
	 { "SbVec4f_length", _wrap_SbVec4f_length, METH_O, "SbVec4f_length(SbVec4f self) -> float"},
	 { "SbVec4f_sqrLength", _wrap_SbVec4f_sqrLength, METH_O, "SbVec4f_sqrLength(SbVec4f self) -> float"},
	 { "SbVec4f_negate", _wrap_SbVec4f_negate, METH_O, "SbVec4f_negate(SbVec4f self)"},
	 { "SbVec4f_normalize", _wrap_SbVec4f_normalize, METH_O, "SbVec4f_normalize(SbVec4f self) -> float"},
	 { "SbVec4f___imul__", _wrap_SbVec4f___imul__, METH_VARARGS, "SbVec4f___imul__(SbVec4f self, float d) -> SbVec4f"},
	 { "SbVec4f___itruediv__", _wrap_SbVec4f___itruediv__, METH_VARARGS, "SbVec4f___itruediv__(SbVec4f self, float d) -> SbVec4f"},
	 { "SbVec4f___iadd__", _wrap_SbVec4f___iadd__, METH_VARARGS, "SbVec4f___iadd__(SbVec4f self, SbVec4f v) -> SbVec4f"},
	 { "SbVec4f___isub__", _wrap_SbVec4f___isub__, METH_VARARGS, "SbVec4f___isub__(SbVec4f self, SbVec4f v) -> SbVec4f"},
	 { "SbVec4f___neg__", _wrap_SbVec4f___neg__, METH_O, "SbVec4f___neg__(SbVec4f self) -> SbVec4f"},
	 { "SbVec4f_output", _wrap_SbVec4f_output, METH_VARARGS, "SbVec4f_output(SbVec4f self, FILE * fp)"},
	 { "SbVec4f___add__", _wrap_SbVec4f___add__, METH_VARARGS, "SbVec4f___add__(SbVec4f self, SbVec4f u) -> SbVec4f"},
	 { "SbVec4f___sub__", _wrap_SbVec4f___sub__, METH_VARARGS, "SbVec4f___sub__(SbVec4f self, SbVec4f u) -> SbVec4f"},
	 { "SbVec4f___mul__", _wrap_SbVec4f___mul__, METH_VARARGS, "\n"
		"SbVec4f___mul__(SbVec4f self, float const d) -> SbVec4f\n"
		"SbVec4f___mul__(SbVec4f self, SbMatrix m) -> SbVec4f\n"
		""},
	 { "SbVec4f___rmul__", _wrap_SbVec4f___rmul__, METH_VARARGS, "SbVec4f___rmul__(SbVec4f self, float const d) -> SbVec4f"},
	 { "SbVec4f___div__", _wrap_SbVec4f___div__, METH_VARARGS, "SbVec4f___div__(SbVec4f self, float const d) -> SbVec4f"},
	 { "SbVec4f___truediv__", _wrap_SbVec4f___truediv__, METH_VARARGS, "SbVec4f___truediv__(SbVec4f self, float const d) -> SbVec4f"},
	 { "SbVec4f___eq__", _wrap_SbVec4f___eq__, METH_VARARGS, "SbVec4f___eq__(SbVec4f self, SbVec4f u) -> int"},
	 { "SbVec4f___nq__", _wrap_SbVec4f___nq__, METH_VARARGS, "SbVec4f___nq__(SbVec4f self, SbVec4f u) -> int"},
	 { "SbVec4f___getitem__", _wrap_SbVec4f___getitem__, METH_VARARGS, "SbVec4f___getitem__(SbVec4f self, int i) -> float"},
	 { "SbVec4f___setitem__", _wrap_SbVec4f___setitem__, METH_VARARGS, "SbVec4f___setitem__(SbVec4f self, int i, float value)"},
	 { "delete_SbVec4f", _wrap_delete_SbVec4f, METH_O, "delete_SbVec4f(SbVec4f self)"},
	 { "SbVec4f_swigregister", SbVec4f_swigregister, METH_O, NULL},
	 { "SbVec4f_swiginit", SbVec4f_swiginit, METH_VARARGS, NULL},
	 { "new_SbRotation", _wrap_new_SbRotation, METH_VARARGS, "\n"
		"SbRotation()\n"
		"SbRotation(SbVec3f axis, float const radians)\n"
		"SbRotation(float const [4] q)\n"
		"SbRotation(float const q0, float const q1, float const q2, float const q3)\n"
		"SbRotation(SbMatrix m)\n"
		"new_SbRotation(SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation\n"
		""},
	 { "SbRotation_getValue", _wrap_SbRotation_getValue, METH_O, "SbRotation_getValue(SbRotation self) -> float const *"},
	 { "SbRotation_getAxisAngle", _wrap_SbRotation_getAxisAngle, METH_O, "SbRotation_getAxisAngle(SbRotation self)"},
	 { "SbRotation_getMatrix", _wrap_SbRotation_getMatrix, METH_O, "SbRotation_getMatrix(SbRotation self)"},
	 { "SbRotation_invert", _wrap_SbRotation_invert, METH_O, "SbRotation_invert(SbRotation self) -> SbRotation"},
	 { "SbRotation_inverse", _wrap_SbRotation_inverse, METH_O, "SbRotation_inverse(SbRotation self) -> SbRotation"},
	 { "SbRotation_setValue", _wrap_SbRotation_setValue, METH_VARARGS, "\n"
		"SbRotation_setValue(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation\n"
		"SbRotation_setValue(SbRotation self, float const [4] q) -> SbRotation\n"
		"SbRotation_setValue(SbRotation self, SbMatrix m) -> SbRotation\n"
		"SbRotation_setValue(SbRotation self, SbVec3f axis, float const radians) -> SbRotation\n"
		"SbRotation_setValue(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation\n"
		""},
	 { "SbRotation___imul__", _wrap_SbRotation___imul__, METH_VARARGS, "\n"
		"SbRotation___imul__(SbRotation self, SbRotation q) -> SbRotation\n"
		"SbRotation___imul__(SbRotation self, float const s) -> SbRotation\n"
		""},
	 { "SbRotation_equals", _wrap_SbRotation_equals, METH_VARARGS, "SbRotation_equals(SbRotation self, SbRotation r, float tolerance) -> SbBool"},
	 { "SbRotation_multVec", _wrap_SbRotation_multVec, METH_VARARGS, "SbRotation_multVec(SbRotation self, SbVec3f src)"},
	 { "SbRotation_scaleAngle", _wrap_SbRotation_scaleAngle, METH_VARARGS, "SbRotation_scaleAngle(SbRotation self, float const scaleFactor)"},
	 { "SbRotation_slerp", _wrap_SbRotation_slerp, METH_VARARGS, "SbRotation_slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"},
	 { "SbRotation_identity", _wrap_SbRotation_identity, METH_NOARGS, "SbRotation_identity() -> SbRotation"},
	 { "SbRotation_toString", _wrap_SbRotation_toString, METH_O, "SbRotation_toString(SbRotation self) -> SbString"},
	 { "SbRotation_fromString", _wrap_SbRotation_fromString, METH_VARARGS, "SbRotation_fromString(SbRotation self, SbString str) -> SbBool"},
	 { "SbRotation_output", _wrap_SbRotation_output, METH_VARARGS, "SbRotation_output(SbRotation self, FILE * fp)"},
	 { "SbRotation___mul__", _wrap_SbRotation___mul__, METH_VARARGS, "\n"
		"SbRotation___mul__(SbRotation self, SbRotation u) -> SbRotation\n"
		"SbRotation___mul__(SbRotation self, double const d) -> SbRotation\n"
		"SbRotation___mul__(SbRotation self, SbVec3f v) -> SbVec3f\n"
		""},
	 { "SbRotation___eq__", _wrap_SbRotation___eq__, METH_VARARGS, "SbRotation___eq__(SbRotation self, SbRotation u) -> int"},
	 { "SbRotation___nq__", _wrap_SbRotation___nq__, METH_VARARGS, "SbRotation___nq__(SbRotation self, SbRotation u) -> int"},
	 { "delete_SbRotation", _wrap_delete_SbRotation, METH_O, "delete_SbRotation(SbRotation self)"},
	 { "SbRotation_swigregister", SbRotation_swigregister, METH_O, NULL},
	 { "SbRotation_swiginit", SbRotation_swiginit, METH_VARARGS, NULL},
	 { "SoGetMatrixAction_getTypeId", _wrap_SoGetMatrixAction_getTypeId, METH_O, "SoGetMatrixAction_getTypeId(SoGetMatrixAction self) -> SoType"},
	 { "SoGetMatrixAction_getClassTypeId", _wrap_SoGetMatrixAction_getClassTypeId, METH_NOARGS, "SoGetMatrixAction_getClassTypeId() -> SoType"},
	 { "SoGetMatrixAction_addMethod", _wrap_SoGetMatrixAction_addMethod, METH_VARARGS, "SoGetMatrixAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoGetMatrixAction_enableElement", _wrap_SoGetMatrixAction_enableElement, METH_VARARGS, "SoGetMatrixAction_enableElement(SoType type, int const stackindex)"},
	 { "SoGetMatrixAction_initClass", _wrap_SoGetMatrixAction_initClass, METH_NOARGS, "SoGetMatrixAction_initClass()"},
	 { "new_SoGetMatrixAction", _wrap_new_SoGetMatrixAction, METH_O, "new_SoGetMatrixAction(SbViewportRegion region) -> SoGetMatrixAction"},
	 { "delete_SoGetMatrixAction", _wrap_delete_SoGetMatrixAction, METH_O, "delete_SoGetMatrixAction(SoGetMatrixAction self)"},
	 { "SoGetMatrixAction_setViewportRegion", _wrap_SoGetMatrixAction_setViewportRegion, METH_VARARGS, "SoGetMatrixAction_setViewportRegion(SoGetMatrixAction self, SbViewportRegion region)"},
	 { "SoGetMatrixAction_getViewportRegion", _wrap_SoGetMatrixAction_getViewportRegion, METH_O, "SoGetMatrixAction_getViewportRegion(SoGetMatrixAction self) -> SbViewportRegion"},
	 { "SoGetMatrixAction_getMatrix", _wrap_SoGetMatrixAction_getMatrix, METH_O, "SoGetMatrixAction_getMatrix(SoGetMatrixAction self) -> SbMatrix"},
	 { "SoGetMatrixAction_getInverse", _wrap_SoGetMatrixAction_getInverse, METH_O, "SoGetMatrixAction_getInverse(SoGetMatrixAction self) -> SbMatrix"},
	 { "SoGetMatrixAction_getTextureMatrix", _wrap_SoGetMatrixAction_getTextureMatrix, METH_O, "SoGetMatrixAction_getTextureMatrix(SoGetMatrixAction self) -> SbMatrix"},
	 { "SoGetMatrixAction_getTextureInverse", _wrap_SoGetMatrixAction_getTextureInverse, METH_O, "SoGetMatrixAction_getTextureInverse(SoGetMatrixAction self) -> SbMatrix"},
	 { "SoGetMatrixAction_swigregister", SoGetMatrixAction_swigregister, METH_O, NULL},
	 { "SoGetMatrixAction_swiginit", SoGetMatrixAction_swiginit, METH_VARARGS, NULL},
	 { "SoGetPrimitiveCountAction_getTypeId", _wrap_SoGetPrimitiveCountAction_getTypeId, METH_O, "SoGetPrimitiveCountAction_getTypeId(SoGetPrimitiveCountAction self) -> SoType"},
	 { "SoGetPrimitiveCountAction_getClassTypeId", _wrap_SoGetPrimitiveCountAction_getClassTypeId, METH_NOARGS, "SoGetPrimitiveCountAction_getClassTypeId() -> SoType"},
	 { "SoGetPrimitiveCountAction_addMethod", _wrap_SoGetPrimitiveCountAction_addMethod, METH_VARARGS, "SoGetPrimitiveCountAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoGetPrimitiveCountAction_enableElement", _wrap_SoGetPrimitiveCountAction_enableElement, METH_VARARGS, "SoGetPrimitiveCountAction_enableElement(SoType type, int const stackindex)"},
	 { "SoGetPrimitiveCountAction_initClass", _wrap_SoGetPrimitiveCountAction_initClass, METH_NOARGS, "SoGetPrimitiveCountAction_initClass()"},
	 { "new_SoGetPrimitiveCountAction", _wrap_new_SoGetPrimitiveCountAction, METH_VARARGS, "\n"
		"SoGetPrimitiveCountAction()\n"
		"new_SoGetPrimitiveCountAction(SbViewportRegion vp) -> SoGetPrimitiveCountAction\n"
		""},
	 { "delete_SoGetPrimitiveCountAction", _wrap_delete_SoGetPrimitiveCountAction, METH_O, "delete_SoGetPrimitiveCountAction(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_getTriangleCount", _wrap_SoGetPrimitiveCountAction_getTriangleCount, METH_O, "SoGetPrimitiveCountAction_getTriangleCount(SoGetPrimitiveCountAction self) -> int"},
	 { "SoGetPrimitiveCountAction_getLineCount", _wrap_SoGetPrimitiveCountAction_getLineCount, METH_O, "SoGetPrimitiveCountAction_getLineCount(SoGetPrimitiveCountAction self) -> int"},
	 { "SoGetPrimitiveCountAction_getPointCount", _wrap_SoGetPrimitiveCountAction_getPointCount, METH_O, "SoGetPrimitiveCountAction_getPointCount(SoGetPrimitiveCountAction self) -> int"},
	 { "SoGetPrimitiveCountAction_getTextCount", _wrap_SoGetPrimitiveCountAction_getTextCount, METH_O, "SoGetPrimitiveCountAction_getTextCount(SoGetPrimitiveCountAction self) -> int"},
	 { "SoGetPrimitiveCountAction_getImageCount", _wrap_SoGetPrimitiveCountAction_getImageCount, METH_O, "SoGetPrimitiveCountAction_getImageCount(SoGetPrimitiveCountAction self) -> int"},
	 { "SoGetPrimitiveCountAction_containsNoPrimitives", _wrap_SoGetPrimitiveCountAction_containsNoPrimitives, METH_O, "SoGetPrimitiveCountAction_containsNoPrimitives(SoGetPrimitiveCountAction self) -> SbBool"},
	 { "SoGetPrimitiveCountAction_containsNonTriangleShapes", _wrap_SoGetPrimitiveCountAction_containsNonTriangleShapes, METH_O, "SoGetPrimitiveCountAction_containsNonTriangleShapes(SoGetPrimitiveCountAction self) -> SbBool"},
	 { "SoGetPrimitiveCountAction_is3DTextCountedAsTriangles", _wrap_SoGetPrimitiveCountAction_is3DTextCountedAsTriangles, METH_O, "SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(SoGetPrimitiveCountAction self) -> SbBool"},
	 { "SoGetPrimitiveCountAction_setCount3DTextAsTriangles", _wrap_SoGetPrimitiveCountAction_setCount3DTextAsTriangles, METH_VARARGS, "SoGetPrimitiveCountAction_setCount3DTextAsTriangles(SoGetPrimitiveCountAction self, SbBool const flag)"},
	 { "SoGetPrimitiveCountAction_canApproximateCount", _wrap_SoGetPrimitiveCountAction_canApproximateCount, METH_O, "SoGetPrimitiveCountAction_canApproximateCount(SoGetPrimitiveCountAction self) -> SbBool"},
	 { "SoGetPrimitiveCountAction_setCanApproximate", _wrap_SoGetPrimitiveCountAction_setCanApproximate, METH_VARARGS, "SoGetPrimitiveCountAction_setCanApproximate(SoGetPrimitiveCountAction self, SbBool const flag)"},
	 { "SoGetPrimitiveCountAction_setDecimationValue", _wrap_SoGetPrimitiveCountAction_setDecimationValue, METH_VARARGS, "SoGetPrimitiveCountAction_setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type, float percentage=1.0)"},
	 { "SoGetPrimitiveCountAction_getDecimationType", _wrap_SoGetPrimitiveCountAction_getDecimationType, METH_O, "SoGetPrimitiveCountAction_getDecimationType(SoGetPrimitiveCountAction self) -> SoDecimationTypeElement::Type"},
	 { "SoGetPrimitiveCountAction_getDecimationPercentage", _wrap_SoGetPrimitiveCountAction_getDecimationPercentage, METH_O, "SoGetPrimitiveCountAction_getDecimationPercentage(SoGetPrimitiveCountAction self) -> float"},
	 { "SoGetPrimitiveCountAction_addNumTriangles", _wrap_SoGetPrimitiveCountAction_addNumTriangles, METH_VARARGS, "SoGetPrimitiveCountAction_addNumTriangles(SoGetPrimitiveCountAction self, int const num)"},
	 { "SoGetPrimitiveCountAction_addNumLines", _wrap_SoGetPrimitiveCountAction_addNumLines, METH_VARARGS, "SoGetPrimitiveCountAction_addNumLines(SoGetPrimitiveCountAction self, int const num)"},
	 { "SoGetPrimitiveCountAction_addNumPoints", _wrap_SoGetPrimitiveCountAction_addNumPoints, METH_VARARGS, "SoGetPrimitiveCountAction_addNumPoints(SoGetPrimitiveCountAction self, int const num)"},
	 { "SoGetPrimitiveCountAction_addNumText", _wrap_SoGetPrimitiveCountAction_addNumText, METH_VARARGS, "SoGetPrimitiveCountAction_addNumText(SoGetPrimitiveCountAction self, int const num)"},
	 { "SoGetPrimitiveCountAction_addNumImage", _wrap_SoGetPrimitiveCountAction_addNumImage, METH_VARARGS, "SoGetPrimitiveCountAction_addNumImage(SoGetPrimitiveCountAction self, int const num)"},
	 { "SoGetPrimitiveCountAction_incNumTriangles", _wrap_SoGetPrimitiveCountAction_incNumTriangles, METH_O, "SoGetPrimitiveCountAction_incNumTriangles(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_incNumLines", _wrap_SoGetPrimitiveCountAction_incNumLines, METH_O, "SoGetPrimitiveCountAction_incNumLines(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_incNumPoints", _wrap_SoGetPrimitiveCountAction_incNumPoints, METH_O, "SoGetPrimitiveCountAction_incNumPoints(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_incNumText", _wrap_SoGetPrimitiveCountAction_incNumText, METH_O, "SoGetPrimitiveCountAction_incNumText(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_incNumImage", _wrap_SoGetPrimitiveCountAction_incNumImage, METH_O, "SoGetPrimitiveCountAction_incNumImage(SoGetPrimitiveCountAction self)"},
	 { "SoGetPrimitiveCountAction_swigregister", SoGetPrimitiveCountAction_swigregister, METH_O, NULL},
	 { "SoGetPrimitiveCountAction_swiginit", SoGetPrimitiveCountAction_swiginit, METH_VARARGS, NULL},
	 { "SoHandleEventAction_getTypeId", _wrap_SoHandleEventAction_getTypeId, METH_O, "SoHandleEventAction_getTypeId(SoHandleEventAction self) -> SoType"},
	 { "SoHandleEventAction_getClassTypeId", _wrap_SoHandleEventAction_getClassTypeId, METH_NOARGS, "SoHandleEventAction_getClassTypeId() -> SoType"},
	 { "SoHandleEventAction_addMethod", _wrap_SoHandleEventAction_addMethod, METH_VARARGS, "SoHandleEventAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoHandleEventAction_enableElement", _wrap_SoHandleEventAction_enableElement, METH_VARARGS, "SoHandleEventAction_enableElement(SoType type, int const stackindex)"},
	 { "SoHandleEventAction_initClass", _wrap_SoHandleEventAction_initClass, METH_NOARGS, "SoHandleEventAction_initClass()"},
	 { "new_SoHandleEventAction", _wrap_new_SoHandleEventAction, METH_O, "new_SoHandleEventAction(SbViewportRegion viewportregion) -> SoHandleEventAction"},
	 { "delete_SoHandleEventAction", _wrap_delete_SoHandleEventAction, METH_O, "delete_SoHandleEventAction(SoHandleEventAction self)"},
	 { "SoHandleEventAction_setViewportRegion", _wrap_SoHandleEventAction_setViewportRegion, METH_VARARGS, "SoHandleEventAction_setViewportRegion(SoHandleEventAction self, SbViewportRegion newregion)"},
	 { "SoHandleEventAction_getViewportRegion", _wrap_SoHandleEventAction_getViewportRegion, METH_O, "SoHandleEventAction_getViewportRegion(SoHandleEventAction self) -> SbViewportRegion"},
	 { "SoHandleEventAction_setEvent", _wrap_SoHandleEventAction_setEvent, METH_VARARGS, "SoHandleEventAction_setEvent(SoHandleEventAction self, SoEvent ev)"},
	 { "SoHandleEventAction_getEvent", _wrap_SoHandleEventAction_getEvent, METH_O, "SoHandleEventAction_getEvent(SoHandleEventAction self) -> SoEvent"},
	 { "SoHandleEventAction_setHandled", _wrap_SoHandleEventAction_setHandled, METH_O, "SoHandleEventAction_setHandled(SoHandleEventAction self)"},
	 { "SoHandleEventAction_isHandled", _wrap_SoHandleEventAction_isHandled, METH_O, "SoHandleEventAction_isHandled(SoHandleEventAction self) -> SbBool"},
	 { "SoHandleEventAction_setGrabber", _wrap_SoHandleEventAction_setGrabber, METH_VARARGS, "SoHandleEventAction_setGrabber(SoHandleEventAction self, SoNode node)"},
	 { "SoHandleEventAction_releaseGrabber", _wrap_SoHandleEventAction_releaseGrabber, METH_O, "SoHandleEventAction_releaseGrabber(SoHandleEventAction self)"},
	 { "SoHandleEventAction_getGrabber", _wrap_SoHandleEventAction_getGrabber, METH_O, "SoHandleEventAction_getGrabber(SoHandleEventAction self) -> SoNode"},
	 { "SoHandleEventAction_setPickRoot", _wrap_SoHandleEventAction_setPickRoot, METH_VARARGS, "SoHandleEventAction_setPickRoot(SoHandleEventAction self, SoNode node)"},
	 { "SoHandleEventAction_getPickRoot", _wrap_SoHandleEventAction_getPickRoot, METH_O, "SoHandleEventAction_getPickRoot(SoHandleEventAction self) -> SoNode"},
	 { "SoHandleEventAction_setPickRadius", _wrap_SoHandleEventAction_setPickRadius, METH_VARARGS, "SoHandleEventAction_setPickRadius(SoHandleEventAction self, float const radiusinpixels)"},
	 { "SoHandleEventAction_getPickRadius", _wrap_SoHandleEventAction_getPickRadius, METH_O, "SoHandleEventAction_getPickRadius(SoHandleEventAction self) -> float"},
	 { "SoHandleEventAction_getPickedPoint", _wrap_SoHandleEventAction_getPickedPoint, METH_O, "SoHandleEventAction_getPickedPoint(SoHandleEventAction self) -> SoPickedPoint"},
	 { "SoHandleEventAction_getPickedPointList", _wrap_SoHandleEventAction_getPickedPointList, METH_O, "SoHandleEventAction_getPickedPointList(SoHandleEventAction self) -> SoPickedPointList"},
	 { "SoHandleEventAction_swigregister", SoHandleEventAction_swigregister, METH_O, NULL},
	 { "SoHandleEventAction_swiginit", SoHandleEventAction_swiginit, METH_VARARGS, NULL},
	 { "SoPickAction_getTypeId", _wrap_SoPickAction_getTypeId, METH_O, "SoPickAction_getTypeId(SoPickAction self) -> SoType"},
	 { "SoPickAction_getClassTypeId", _wrap_SoPickAction_getClassTypeId, METH_NOARGS, "SoPickAction_getClassTypeId() -> SoType"},
	 { "SoPickAction_addMethod", _wrap_SoPickAction_addMethod, METH_VARARGS, "SoPickAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoPickAction_enableElement", _wrap_SoPickAction_enableElement, METH_VARARGS, "SoPickAction_enableElement(SoType type, int const stackindex)"},
	 { "SoPickAction_initClass", _wrap_SoPickAction_initClass, METH_NOARGS, "SoPickAction_initClass()"},
	 { "SoPickAction_setViewportRegion", _wrap_SoPickAction_setViewportRegion, METH_VARARGS, "SoPickAction_setViewportRegion(SoPickAction self, SbViewportRegion newregion)"},
	 { "SoPickAction_getViewportRegion", _wrap_SoPickAction_getViewportRegion, METH_O, "SoPickAction_getViewportRegion(SoPickAction self) -> SbViewportRegion"},
	 { "SoPickAction_enableCulling", _wrap_SoPickAction_enableCulling, METH_VARARGS, "SoPickAction_enableCulling(SoPickAction self, SbBool const flag)"},
	 { "SoPickAction_isCullingEnabled", _wrap_SoPickAction_isCullingEnabled, METH_O, "SoPickAction_isCullingEnabled(SoPickAction self) -> SbBool"},
	 { "SoPickAction_swigregister", SoPickAction_swigregister, METH_O, NULL},
	 { "SoRayPickAction_getTypeId", _wrap_SoRayPickAction_getTypeId, METH_O, "SoRayPickAction_getTypeId(SoRayPickAction self) -> SoType"},
	 { "SoRayPickAction_getClassTypeId", _wrap_SoRayPickAction_getClassTypeId, METH_NOARGS, "SoRayPickAction_getClassTypeId() -> SoType"},
	 { "SoRayPickAction_addMethod", _wrap_SoRayPickAction_addMethod, METH_VARARGS, "SoRayPickAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoRayPickAction_enableElement", _wrap_SoRayPickAction_enableElement, METH_VARARGS, "SoRayPickAction_enableElement(SoType type, int const stackindex)"},
	 { "new_SoRayPickAction", _wrap_new_SoRayPickAction, METH_O, "new_SoRayPickAction(SbViewportRegion viewportregion) -> SoRayPickAction"},
	 { "delete_SoRayPickAction", _wrap_delete_SoRayPickAction, METH_O, "delete_SoRayPickAction(SoRayPickAction self)"},
	 { "SoRayPickAction_initClass", _wrap_SoRayPickAction_initClass, METH_NOARGS, "SoRayPickAction_initClass()"},
	 { "SoRayPickAction_setPoint", _wrap_SoRayPickAction_setPoint, METH_VARARGS, "SoRayPickAction_setPoint(SoRayPickAction self, SbVec2s viewportPoint)"},
	 { "SoRayPickAction_setNormalizedPoint", _wrap_SoRayPickAction_setNormalizedPoint, METH_VARARGS, "SoRayPickAction_setNormalizedPoint(SoRayPickAction self, SbVec2f normpoint)"},
	 { "SoRayPickAction_setRadius", _wrap_SoRayPickAction_setRadius, METH_VARARGS, "SoRayPickAction_setRadius(SoRayPickAction self, float const radiusinpixels)"},
	 { "SoRayPickAction_getRadius", _wrap_SoRayPickAction_getRadius, METH_O, "SoRayPickAction_getRadius(SoRayPickAction self) -> float"},
	 { "SoRayPickAction_setRay", _wrap_SoRayPickAction_setRay, METH_VARARGS, "SoRayPickAction_setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0, float fardistance=-1.0)"},
	 { "SoRayPickAction_setPickAll", _wrap_SoRayPickAction_setPickAll, METH_VARARGS, "SoRayPickAction_setPickAll(SoRayPickAction self, SbBool const flag)"},
	 { "SoRayPickAction_isPickAll", _wrap_SoRayPickAction_isPickAll, METH_O, "SoRayPickAction_isPickAll(SoRayPickAction self) -> SbBool"},
	 { "SoRayPickAction_getPickedPointList", _wrap_SoRayPickAction_getPickedPointList, METH_O, "SoRayPickAction_getPickedPointList(SoRayPickAction self) -> SoPickedPointList"},
	 { "SoRayPickAction_getPickedPoint", _wrap_SoRayPickAction_getPickedPoint, METH_VARARGS, "SoRayPickAction_getPickedPoint(SoRayPickAction self, int const index=0) -> SoPickedPoint"},
	 { "SoRayPickAction_computeWorldSpaceRay", _wrap_SoRayPickAction_computeWorldSpaceRay, METH_O, "SoRayPickAction_computeWorldSpaceRay(SoRayPickAction self)"},
	 { "SoRayPickAction_hasWorldSpaceRay", _wrap_SoRayPickAction_hasWorldSpaceRay, METH_O, "SoRayPickAction_hasWorldSpaceRay(SoRayPickAction self) -> SbBool"},
	 { "SoRayPickAction_setObjectSpace", _wrap_SoRayPickAction_setObjectSpace, METH_VARARGS, "\n"
		"SoRayPickAction_setObjectSpace(SoRayPickAction self)\n"
		"SoRayPickAction_setObjectSpace(SoRayPickAction self)\n"
		""},
	 { "SoRayPickAction_intersect", _wrap_SoRayPickAction_intersect, METH_VARARGS, "\n"
		"SoRayPickAction_intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f intersection, SbVec3f barycentric, SbBool & front) -> SbBool\n"
		"SoRayPickAction_intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f intersection) -> SbBool\n"
		"SoRayPickAction_intersect(SoRayPickAction self, SbVec3f point) -> SbBool\n"
		"SoRayPickAction_intersect(SoRayPickAction self, SbBox3f box, SbBool const usefullviewvolume=1) -> SbBool\n"
		"SoRayPickAction_intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection, SbBool const usefullviewvolume=1) -> SbBool\n"
		""},
	 { "SoRayPickAction_getViewVolume", _wrap_SoRayPickAction_getViewVolume, METH_O, "SoRayPickAction_getViewVolume(SoRayPickAction self) -> SbViewVolume"},
	 { "SoRayPickAction_getLine", _wrap_SoRayPickAction_getLine, METH_O, "SoRayPickAction_getLine(SoRayPickAction self) -> SbLine"},
	 { "SoRayPickAction_isBetweenPlanes", _wrap_SoRayPickAction_isBetweenPlanes, METH_VARARGS, "SoRayPickAction_isBetweenPlanes(SoRayPickAction self, SbVec3f intersection) -> SbBool"},
	 { "SoRayPickAction_addIntersection", _wrap_SoRayPickAction_addIntersection, METH_VARARGS, "SoRayPickAction_addIntersection(SoRayPickAction self, SbVec3f objectspacepoint, SbBool frontpick=1) -> SoPickedPoint"},
	 { "SoRayPickAction_reset", _wrap_SoRayPickAction_reset, METH_O, "SoRayPickAction_reset(SoRayPickAction self)"},
	 { "SoRayPickAction_swigregister", SoRayPickAction_swigregister, METH_O, NULL},
	 { "SoRayPickAction_swiginit", SoRayPickAction_swiginit, METH_VARARGS, NULL},
	 { "SoSearchAction_getTypeId", _wrap_SoSearchAction_getTypeId, METH_O, "SoSearchAction_getTypeId(SoSearchAction self) -> SoType"},
	 { "SoSearchAction_getClassTypeId", _wrap_SoSearchAction_getClassTypeId, METH_NOARGS, "SoSearchAction_getClassTypeId() -> SoType"},
	 { "SoSearchAction_addMethod", _wrap_SoSearchAction_addMethod, METH_VARARGS, "SoSearchAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoSearchAction_enableElement", _wrap_SoSearchAction_enableElement, METH_VARARGS, "SoSearchAction_enableElement(SoType type, int const stackindex)"},
	 { "SoSearchAction_initClass", _wrap_SoSearchAction_initClass, METH_NOARGS, "SoSearchAction_initClass()"},
	 { "new_SoSearchAction", _wrap_new_SoSearchAction, METH_NOARGS, "new_SoSearchAction() -> SoSearchAction"},
	 { "delete_SoSearchAction", _wrap_delete_SoSearchAction, METH_O, "delete_SoSearchAction(SoSearchAction self)"},
	 { "SoSearchAction_setNode", _wrap_SoSearchAction_setNode, METH_VARARGS, "SoSearchAction_setNode(SoSearchAction self, SoNode node)"},
	 { "SoSearchAction_getNode", _wrap_SoSearchAction_getNode, METH_O, "SoSearchAction_getNode(SoSearchAction self) -> SoNode"},
	 { "SoSearchAction_setType", _wrap_SoSearchAction_setType, METH_VARARGS, "SoSearchAction_setType(SoSearchAction self, SoType type, SbBool const chkderived=1)"},
	 { "SoSearchAction_getType", _wrap_SoSearchAction_getType, METH_VARARGS, "SoSearchAction_getType(SoSearchAction self, SbBool & chkderived) -> SoType"},
	 { "SoSearchAction_setName", _wrap_SoSearchAction_setName, METH_VARARGS, "SoSearchAction_setName(SoSearchAction self, SbName name)"},
	 { "SoSearchAction_getName", _wrap_SoSearchAction_getName, METH_O, "SoSearchAction_getName(SoSearchAction self) -> SbName"},
	 { "SoSearchAction_setFind", _wrap_SoSearchAction_setFind, METH_VARARGS, "SoSearchAction_setFind(SoSearchAction self, int const what)"},
	 { "SoSearchAction_getFind", _wrap_SoSearchAction_getFind, METH_O, "SoSearchAction_getFind(SoSearchAction self) -> int"},
	 { "SoSearchAction_setInterest", _wrap_SoSearchAction_setInterest, METH_VARARGS, "SoSearchAction_setInterest(SoSearchAction self, SoSearchAction::Interest const interest)"},
	 { "SoSearchAction_getInterest", _wrap_SoSearchAction_getInterest, METH_O, "SoSearchAction_getInterest(SoSearchAction self) -> SoSearchAction::Interest"},
	 { "SoSearchAction_setSearchingAll", _wrap_SoSearchAction_setSearchingAll, METH_VARARGS, "SoSearchAction_setSearchingAll(SoSearchAction self, SbBool const searchall)"},
	 { "SoSearchAction_isSearchingAll", _wrap_SoSearchAction_isSearchingAll, METH_O, "SoSearchAction_isSearchingAll(SoSearchAction self) -> SbBool"},
	 { "SoSearchAction_getPath", _wrap_SoSearchAction_getPath, METH_O, "SoSearchAction_getPath(SoSearchAction self) -> SoPath"},
	 { "SoSearchAction_getPaths", _wrap_SoSearchAction_getPaths, METH_O, "SoSearchAction_getPaths(SoSearchAction self) -> SoPathList"},
	 { "SoSearchAction_reset", _wrap_SoSearchAction_reset, METH_O, "SoSearchAction_reset(SoSearchAction self)"},
	 { "SoSearchAction_setFound", _wrap_SoSearchAction_setFound, METH_O, "SoSearchAction_setFound(SoSearchAction self)"},
	 { "SoSearchAction_isFound", _wrap_SoSearchAction_isFound, METH_O, "SoSearchAction_isFound(SoSearchAction self) -> SbBool"},
	 { "SoSearchAction_addPath", _wrap_SoSearchAction_addPath, METH_VARARGS, "SoSearchAction_addPath(SoSearchAction self, SoPath path)"},
	 { "SoSearchAction_duringSearchAll_get", _wrap_SoSearchAction_duringSearchAll_get, METH_VARARGS, NULL},
	 { "SoSearchAction_duringSearchAll_set", _wrap_SoSearchAction_duringSearchAll_set, METH_O, NULL},
	 { "SoSearchAction_swigregister", SoSearchAction_swigregister, METH_O, NULL},
	 { "SoSearchAction_swiginit", SoSearchAction_swiginit, METH_VARARGS, NULL},
	 { "SoSimplifyAction_getTypeId", _wrap_SoSimplifyAction_getTypeId, METH_O, "SoSimplifyAction_getTypeId(SoSimplifyAction self) -> SoType"},
	 { "SoSimplifyAction_getClassTypeId", _wrap_SoSimplifyAction_getClassTypeId, METH_NOARGS, "SoSimplifyAction_getClassTypeId() -> SoType"},
	 { "SoSimplifyAction_addMethod", _wrap_SoSimplifyAction_addMethod, METH_VARARGS, "SoSimplifyAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoSimplifyAction_enableElement", _wrap_SoSimplifyAction_enableElement, METH_VARARGS, "SoSimplifyAction_enableElement(SoType type, int const stackindex)"},
	 { "SoSimplifyAction_initClass", _wrap_SoSimplifyAction_initClass, METH_NOARGS, "SoSimplifyAction_initClass()"},
	 { "new_SoSimplifyAction", _wrap_new_SoSimplifyAction, METH_NOARGS, "new_SoSimplifyAction() -> SoSimplifyAction"},
	 { "delete_SoSimplifyAction", _wrap_delete_SoSimplifyAction, METH_O, "delete_SoSimplifyAction(SoSimplifyAction self)"},
	 { "SoSimplifyAction_apply", _wrap_SoSimplifyAction_apply, METH_VARARGS, "\n"
		"SoSimplifyAction_apply(SoSimplifyAction self, SoNode root)\n"
		"SoSimplifyAction_apply(SoSimplifyAction self, SoPath path)\n"
		"SoSimplifyAction_apply(SoSimplifyAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoSimplifyAction_swigregister", SoSimplifyAction_swigregister, METH_O, NULL},
	 { "SoSimplifyAction_swiginit", SoSimplifyAction_swiginit, METH_VARARGS, NULL},
	 { "SoReorganizeAction_getTypeId", _wrap_SoReorganizeAction_getTypeId, METH_O, "SoReorganizeAction_getTypeId(SoReorganizeAction self) -> SoType"},
	 { "SoReorganizeAction_getClassTypeId", _wrap_SoReorganizeAction_getClassTypeId, METH_NOARGS, "SoReorganizeAction_getClassTypeId() -> SoType"},
	 { "SoReorganizeAction_addMethod", _wrap_SoReorganizeAction_addMethod, METH_VARARGS, "SoReorganizeAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoReorganizeAction_enableElement", _wrap_SoReorganizeAction_enableElement, METH_VARARGS, "SoReorganizeAction_enableElement(SoType type, int const stackindex)"},
	 { "SoReorganizeAction_initClass", _wrap_SoReorganizeAction_initClass, METH_NOARGS, "SoReorganizeAction_initClass()"},
	 { "new_SoReorganizeAction", _wrap_new_SoReorganizeAction, METH_VARARGS, "SoReorganizeAction(SoSimplifier * simplifier=None)"},
	 { "delete_SoReorganizeAction", _wrap_delete_SoReorganizeAction, METH_O, "delete_SoReorganizeAction(SoReorganizeAction self)"},
	 { "SoReorganizeAction_getSimplifiedSceneGraph", _wrap_SoReorganizeAction_getSimplifiedSceneGraph, METH_O, "SoReorganizeAction_getSimplifiedSceneGraph(SoReorganizeAction self) -> SoSeparator"},
	 { "SoReorganizeAction_generateNormals", _wrap_SoReorganizeAction_generateNormals, METH_VARARGS, "SoReorganizeAction_generateNormals(SoReorganizeAction self, SbBool onoff)"},
	 { "SoReorganizeAction_areNormalGenerated", _wrap_SoReorganizeAction_areNormalGenerated, METH_O, "SoReorganizeAction_areNormalGenerated(SoReorganizeAction self) -> SbBool"},
	 { "SoReorganizeAction_generateTriangleStrips", _wrap_SoReorganizeAction_generateTriangleStrips, METH_VARARGS, "SoReorganizeAction_generateTriangleStrips(SoReorganizeAction self, SbBool onoff)"},
	 { "SoReorganizeAction_areTriangleStripGenerated", _wrap_SoReorganizeAction_areTriangleStripGenerated, METH_O, "SoReorganizeAction_areTriangleStripGenerated(SoReorganizeAction self) -> SbBool"},
	 { "SoReorganizeAction_generateTexCoords", _wrap_SoReorganizeAction_generateTexCoords, METH_VARARGS, "SoReorganizeAction_generateTexCoords(SoReorganizeAction self, SbBool onoff)"},
	 { "SoReorganizeAction_areTexCoordsGenerated", _wrap_SoReorganizeAction_areTexCoordsGenerated, METH_O, "SoReorganizeAction_areTexCoordsGenerated(SoReorganizeAction self) -> SbBool"},
	 { "SoReorganizeAction_generateVPNodes", _wrap_SoReorganizeAction_generateVPNodes, METH_VARARGS, "SoReorganizeAction_generateVPNodes(SoReorganizeAction self, SbBool onoff)"},
	 { "SoReorganizeAction_areVPNodesGenerated", _wrap_SoReorganizeAction_areVPNodesGenerated, METH_O, "SoReorganizeAction_areVPNodesGenerated(SoReorganizeAction self) -> SbBool"},
	 { "SoReorganizeAction_matchIndexArrays", _wrap_SoReorganizeAction_matchIndexArrays, METH_VARARGS, "SoReorganizeAction_matchIndexArrays(SoReorganizeAction self, SbBool onoff)"},
	 { "SoReorganizeAction_areIndexArraysMatched", _wrap_SoReorganizeAction_areIndexArraysMatched, METH_O, "SoReorganizeAction_areIndexArraysMatched(SoReorganizeAction self) -> SbBool"},
	 { "SoReorganizeAction_getSimplifier", _wrap_SoReorganizeAction_getSimplifier, METH_O, "SoReorganizeAction_getSimplifier(SoReorganizeAction self) -> SoSimplifier *"},
	 { "SoReorganizeAction_apply", _wrap_SoReorganizeAction_apply, METH_VARARGS, "\n"
		"SoReorganizeAction_apply(SoReorganizeAction self, SoNode root)\n"
		"SoReorganizeAction_apply(SoReorganizeAction self, SoPath path)\n"
		"SoReorganizeAction_apply(SoReorganizeAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoReorganizeAction_startReport", _wrap_SoReorganizeAction_startReport, METH_O, "SoReorganizeAction_startReport(char const * msg)"},
	 { "SoReorganizeAction_finishReport", _wrap_SoReorganizeAction_finishReport, METH_NOARGS, "SoReorganizeAction_finishReport()"},
	 { "SoReorganizeAction_swigregister", SoReorganizeAction_swigregister, METH_O, NULL},
	 { "SoReorganizeAction_swiginit", SoReorganizeAction_swiginit, METH_VARARGS, NULL},
	 { "SoWriteAction_getTypeId", _wrap_SoWriteAction_getTypeId, METH_O, "SoWriteAction_getTypeId(SoWriteAction self) -> SoType"},
	 { "SoWriteAction_getClassTypeId", _wrap_SoWriteAction_getClassTypeId, METH_NOARGS, "SoWriteAction_getClassTypeId() -> SoType"},
	 { "SoWriteAction_addMethod", _wrap_SoWriteAction_addMethod, METH_VARARGS, "SoWriteAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoWriteAction_enableElement", _wrap_SoWriteAction_enableElement, METH_VARARGS, "SoWriteAction_enableElement(SoType type, int const stackindex)"},
	 { "new_SoWriteAction", _wrap_new_SoWriteAction, METH_VARARGS, "\n"
		"SoWriteAction()\n"
		"new_SoWriteAction(SoOutput out) -> SoWriteAction\n"
		""},
	 { "delete_SoWriteAction", _wrap_delete_SoWriteAction, METH_O, "delete_SoWriteAction(SoWriteAction self)"},
	 { "SoWriteAction_initClass", _wrap_SoWriteAction_initClass, METH_NOARGS, "SoWriteAction_initClass()"},
	 { "SoWriteAction_getOutput", _wrap_SoWriteAction_getOutput, METH_O, "SoWriteAction_getOutput(SoWriteAction self) -> SoOutput"},
	 { "SoWriteAction_continueToApply", _wrap_SoWriteAction_continueToApply, METH_VARARGS, "\n"
		"SoWriteAction_continueToApply(SoWriteAction self, SoNode node)\n"
		"SoWriteAction_continueToApply(SoWriteAction self, SoPath path)\n"
		""},
	 { "SoWriteAction_swigregister", SoWriteAction_swigregister, METH_O, NULL},
	 { "SoWriteAction_swiginit", SoWriteAction_swiginit, METH_VARARGS, NULL},
	 { "SoAudioRenderAction_getTypeId", _wrap_SoAudioRenderAction_getTypeId, METH_O, "SoAudioRenderAction_getTypeId(SoAudioRenderAction self) -> SoType"},
	 { "SoAudioRenderAction_getClassTypeId", _wrap_SoAudioRenderAction_getClassTypeId, METH_NOARGS, "SoAudioRenderAction_getClassTypeId() -> SoType"},
	 { "SoAudioRenderAction_addMethod", _wrap_SoAudioRenderAction_addMethod, METH_VARARGS, "SoAudioRenderAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoAudioRenderAction_enableElement", _wrap_SoAudioRenderAction_enableElement, METH_VARARGS, "SoAudioRenderAction_enableElement(SoType type, int const stackindex)"},
	 { "SoAudioRenderAction_initClass", _wrap_SoAudioRenderAction_initClass, METH_NOARGS, "SoAudioRenderAction_initClass()"},
	 { "new_SoAudioRenderAction", _wrap_new_SoAudioRenderAction, METH_NOARGS, "new_SoAudioRenderAction() -> SoAudioRenderAction"},
	 { "delete_SoAudioRenderAction", _wrap_delete_SoAudioRenderAction, METH_O, "delete_SoAudioRenderAction(SoAudioRenderAction self)"},
	 { "SoAudioRenderAction_callDoAction", _wrap_SoAudioRenderAction_callDoAction, METH_VARARGS, "SoAudioRenderAction_callDoAction(SoAction action, SoNode node)"},
	 { "SoAudioRenderAction_callAudioRender", _wrap_SoAudioRenderAction_callAudioRender, METH_VARARGS, "SoAudioRenderAction_callAudioRender(SoAction action, SoNode node)"},
	 { "SoAudioRenderAction_swigregister", SoAudioRenderAction_swigregister, METH_O, NULL},
	 { "SoAudioRenderAction_swiginit", SoAudioRenderAction_swiginit, METH_VARARGS, NULL},
	 { "SoIntersectingPrimitive_path_set", _wrap_SoIntersectingPrimitive_path_set, METH_VARARGS, "SoIntersectingPrimitive_path_set(SoIntersectingPrimitive self, SoPath path)"},
	 { "SoIntersectingPrimitive_path_get", _wrap_SoIntersectingPrimitive_path_get, METH_O, "SoIntersectingPrimitive_path_get(SoIntersectingPrimitive self) -> SoPath"},
	 { "SoIntersectingPrimitive_type_set", _wrap_SoIntersectingPrimitive_type_set, METH_VARARGS, "SoIntersectingPrimitive_type_set(SoIntersectingPrimitive self, enum SoIntersectingPrimitive::PrimitiveType type)"},
	 { "SoIntersectingPrimitive_type_get", _wrap_SoIntersectingPrimitive_type_get, METH_O, "SoIntersectingPrimitive_type_get(SoIntersectingPrimitive self) -> enum SoIntersectingPrimitive::PrimitiveType"},
	 { "SoIntersectingPrimitive_vertex_set", _wrap_SoIntersectingPrimitive_vertex_set, METH_VARARGS, "SoIntersectingPrimitive_vertex_set(SoIntersectingPrimitive self, SbVec3f vertex)"},
	 { "SoIntersectingPrimitive_vertex_get", _wrap_SoIntersectingPrimitive_vertex_get, METH_O, "SoIntersectingPrimitive_vertex_get(SoIntersectingPrimitive self) -> SbVec3f"},
	 { "SoIntersectingPrimitive_xf_vertex_set", _wrap_SoIntersectingPrimitive_xf_vertex_set, METH_VARARGS, "SoIntersectingPrimitive_xf_vertex_set(SoIntersectingPrimitive self, SbVec3f xf_vertex)"},
	 { "SoIntersectingPrimitive_xf_vertex_get", _wrap_SoIntersectingPrimitive_xf_vertex_get, METH_O, "SoIntersectingPrimitive_xf_vertex_get(SoIntersectingPrimitive self) -> SbVec3f"},
	 { "new_SoIntersectingPrimitive", _wrap_new_SoIntersectingPrimitive, METH_NOARGS, "new_SoIntersectingPrimitive() -> SoIntersectingPrimitive"},
	 { "delete_SoIntersectingPrimitive", _wrap_delete_SoIntersectingPrimitive, METH_O, "delete_SoIntersectingPrimitive(SoIntersectingPrimitive self)"},
	 { "SoIntersectingPrimitive_swigregister", SoIntersectingPrimitive_swigregister, METH_O, NULL},
	 { "SoIntersectingPrimitive_swiginit", SoIntersectingPrimitive_swiginit, METH_VARARGS, NULL},
	 { "SoIntersectionDetectionAction_getTypeId", _wrap_SoIntersectionDetectionAction_getTypeId, METH_O, "SoIntersectionDetectionAction_getTypeId(SoIntersectionDetectionAction self) -> SoType"},
	 { "SoIntersectionDetectionAction_getClassTypeId", _wrap_SoIntersectionDetectionAction_getClassTypeId, METH_NOARGS, "SoIntersectionDetectionAction_getClassTypeId() -> SoType"},
	 { "SoIntersectionDetectionAction_addMethod", _wrap_SoIntersectionDetectionAction_addMethod, METH_VARARGS, "SoIntersectionDetectionAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoIntersectionDetectionAction_enableElement", _wrap_SoIntersectionDetectionAction_enableElement, METH_VARARGS, "SoIntersectionDetectionAction_enableElement(SoType type, int const stackindex)"},
	 { "SoIntersectionDetectionAction_initClass", _wrap_SoIntersectionDetectionAction_initClass, METH_NOARGS, "SoIntersectionDetectionAction_initClass()"},
	 { "new_SoIntersectionDetectionAction", _wrap_new_SoIntersectionDetectionAction, METH_NOARGS, "new_SoIntersectionDetectionAction() -> SoIntersectionDetectionAction"},
	 { "delete_SoIntersectionDetectionAction", _wrap_delete_SoIntersectionDetectionAction, METH_O, "delete_SoIntersectionDetectionAction(SoIntersectionDetectionAction self)"},
	 { "SoIntersectionDetectionAction_setIntersectionDetectionEpsilon", _wrap_SoIntersectionDetectionAction_setIntersectionDetectionEpsilon, METH_VARARGS, "SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(SoIntersectionDetectionAction self, float epsilon)"},
	 { "SoIntersectionDetectionAction_getIntersectionDetectionEpsilon", _wrap_SoIntersectionDetectionAction_getIntersectionDetectionEpsilon, METH_O, "SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(SoIntersectionDetectionAction self) -> float"},
	 { "SoIntersectionDetectionAction_setIntersectionEpsilon", _wrap_SoIntersectionDetectionAction_setIntersectionEpsilon, METH_O, "SoIntersectionDetectionAction_setIntersectionEpsilon(float epsilon)"},
	 { "SoIntersectionDetectionAction_getIntersectionEpsilon", _wrap_SoIntersectionDetectionAction_getIntersectionEpsilon, METH_NOARGS, "SoIntersectionDetectionAction_getIntersectionEpsilon() -> float"},
	 { "SoIntersectionDetectionAction_setTypeEnabled", _wrap_SoIntersectionDetectionAction_setTypeEnabled, METH_VARARGS, "SoIntersectionDetectionAction_setTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool enable)"},
	 { "SoIntersectionDetectionAction_isTypeEnabled", _wrap_SoIntersectionDetectionAction_isTypeEnabled, METH_VARARGS, "SoIntersectionDetectionAction_isTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool checkgroups=0) -> SbBool"},
	 { "SoIntersectionDetectionAction_setManipsEnabled", _wrap_SoIntersectionDetectionAction_setManipsEnabled, METH_VARARGS, "SoIntersectionDetectionAction_setManipsEnabled(SoIntersectionDetectionAction self, SbBool enable)"},
	 { "SoIntersectionDetectionAction_isManipsEnabled", _wrap_SoIntersectionDetectionAction_isManipsEnabled, METH_O, "SoIntersectionDetectionAction_isManipsEnabled(SoIntersectionDetectionAction self) -> SbBool"},
	 { "SoIntersectionDetectionAction_setDraggersEnabled", _wrap_SoIntersectionDetectionAction_setDraggersEnabled, METH_VARARGS, "SoIntersectionDetectionAction_setDraggersEnabled(SoIntersectionDetectionAction self, SbBool enable)"},
	 { "SoIntersectionDetectionAction_isDraggersEnabled", _wrap_SoIntersectionDetectionAction_isDraggersEnabled, METH_O, "SoIntersectionDetectionAction_isDraggersEnabled(SoIntersectionDetectionAction self) -> SbBool"},
	 { "SoIntersectionDetectionAction_setShapeInternalsEnabled", _wrap_SoIntersectionDetectionAction_setShapeInternalsEnabled, METH_VARARGS, "SoIntersectionDetectionAction_setShapeInternalsEnabled(SoIntersectionDetectionAction self, SbBool enable)"},
	 { "SoIntersectionDetectionAction_isShapeInternalsEnabled", _wrap_SoIntersectionDetectionAction_isShapeInternalsEnabled, METH_O, "SoIntersectionDetectionAction_isShapeInternalsEnabled(SoIntersectionDetectionAction self) -> SbBool"},
	 { "SoIntersectionDetectionAction_apply", _wrap_SoIntersectionDetectionAction_apply, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_apply(SoIntersectionDetectionAction self, SoNode node)\n"
		"SoIntersectionDetectionAction_apply(SoIntersectionDetectionAction self, SoPath path)\n"
		"SoIntersectionDetectionAction_apply(SoIntersectionDetectionAction self, SoPathList paths, SbBool obeysRules=0)\n"
		""},
	 { "SoIntersectionDetectionAction_addVisitationCallback", _wrap_SoIntersectionDetectionAction_addVisitationCallback, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_addVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)\n"
		"SoIntersectionDetectionAction_addVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)\n"
		""},
	 { "SoIntersectionDetectionAction_removeVisitationCallback", _wrap_SoIntersectionDetectionAction_removeVisitationCallback, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)\n"
		"SoIntersectionDetectionAction_removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)\n"
		""},
	 { "SoIntersectionDetectionAction_setFilterCallback", _wrap_SoIntersectionDetectionAction_setFilterCallback, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb, void * closure=None)\n"
		"SoIntersectionDetectionAction_setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)\n"
		""},
	 { "SoIntersectionDetectionAction_addIntersectionCallback", _wrap_SoIntersectionDetectionAction_addIntersectionCallback, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)\n"
		"SoIntersectionDetectionAction_addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)\n"
		""},
	 { "SoIntersectionDetectionAction_removeIntersectionCallback", _wrap_SoIntersectionDetectionAction_removeIntersectionCallback, METH_VARARGS, "\n"
		"SoIntersectionDetectionAction_removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)\n"
		"SoIntersectionDetectionAction_removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)\n"
		""},
	 { "SoIntersectionDetectionAction_swigregister", SoIntersectionDetectionAction_swigregister, METH_O, NULL},
	 { "SoIntersectionDetectionAction_swiginit", SoIntersectionDetectionAction_swiginit, METH_VARARGS, NULL},
	 { "SoToVRMLAction_getTypeId", _wrap_SoToVRMLAction_getTypeId, METH_O, "SoToVRMLAction_getTypeId(SoToVRMLAction self) -> SoType"},
	 { "SoToVRMLAction_getClassTypeId", _wrap_SoToVRMLAction_getClassTypeId, METH_NOARGS, "SoToVRMLAction_getClassTypeId() -> SoType"},
	 { "SoToVRMLAction_addMethod", _wrap_SoToVRMLAction_addMethod, METH_VARARGS, "SoToVRMLAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoToVRMLAction_enableElement", _wrap_SoToVRMLAction_enableElement, METH_VARARGS, "SoToVRMLAction_enableElement(SoType type, int const stackindex)"},
	 { "SoToVRMLAction_initClass", _wrap_SoToVRMLAction_initClass, METH_NOARGS, "SoToVRMLAction_initClass()"},
	 { "new_SoToVRMLAction", _wrap_new_SoToVRMLAction, METH_NOARGS, "new_SoToVRMLAction() -> SoToVRMLAction"},
	 { "delete_SoToVRMLAction", _wrap_delete_SoToVRMLAction, METH_O, "delete_SoToVRMLAction(SoToVRMLAction self)"},
	 { "SoToVRMLAction_apply", _wrap_SoToVRMLAction_apply, METH_VARARGS, "\n"
		"SoToVRMLAction_apply(SoToVRMLAction self, SoNode node)\n"
		"SoToVRMLAction_apply(SoToVRMLAction self, SoPath path)\n"
		"SoToVRMLAction_apply(SoToVRMLAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoToVRMLAction_getVRMLSceneGraph", _wrap_SoToVRMLAction_getVRMLSceneGraph, METH_O, "SoToVRMLAction_getVRMLSceneGraph(SoToVRMLAction self) -> SoNode"},
	 { "SoToVRMLAction_expandSoFile", _wrap_SoToVRMLAction_expandSoFile, METH_VARARGS, "SoToVRMLAction_expandSoFile(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_areSoFileExpanded", _wrap_SoToVRMLAction_areSoFileExpanded, METH_O, "SoToVRMLAction_areSoFileExpanded(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_setUrlName", _wrap_SoToVRMLAction_setUrlName, METH_VARARGS, "SoToVRMLAction_setUrlName(SoToVRMLAction self, SbString name)"},
	 { "SoToVRMLAction_getUrlName", _wrap_SoToVRMLAction_getUrlName, METH_O, "SoToVRMLAction_getUrlName(SoToVRMLAction self) -> SbString"},
	 { "SoToVRMLAction_writeTexCoords", _wrap_SoToVRMLAction_writeTexCoords, METH_VARARGS, "SoToVRMLAction_writeTexCoords(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_areTexCoordWritten", _wrap_SoToVRMLAction_areTexCoordWritten, METH_O, "SoToVRMLAction_areTexCoordWritten(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_expandTexture2Node", _wrap_SoToVRMLAction_expandTexture2Node, METH_VARARGS, "SoToVRMLAction_expandTexture2Node(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_areTexture2NodeExpanded", _wrap_SoToVRMLAction_areTexture2NodeExpanded, METH_O, "SoToVRMLAction_areTexture2NodeExpanded(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_keepUnknownNodes", _wrap_SoToVRMLAction_keepUnknownNodes, METH_VARARGS, "SoToVRMLAction_keepUnknownNodes(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_areUnknownNodeKept", _wrap_SoToVRMLAction_areUnknownNodeKept, METH_O, "SoToVRMLAction_areUnknownNodeKept(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_convertInlineNodes", _wrap_SoToVRMLAction_convertInlineNodes, METH_VARARGS, "SoToVRMLAction_convertInlineNodes(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_doConvertInlineNodes", _wrap_SoToVRMLAction_doConvertInlineNodes, METH_O, "SoToVRMLAction_doConvertInlineNodes(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_conditionalConversion", _wrap_SoToVRMLAction_conditionalConversion, METH_VARARGS, "SoToVRMLAction_conditionalConversion(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_doConditionalConversion", _wrap_SoToVRMLAction_doConditionalConversion, METH_O, "SoToVRMLAction_doConditionalConversion(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_setVerbosity", _wrap_SoToVRMLAction_setVerbosity, METH_VARARGS, "SoToVRMLAction_setVerbosity(SoToVRMLAction self, SbBool flag)"},
	 { "SoToVRMLAction_isVerbose", _wrap_SoToVRMLAction_isVerbose, METH_O, "SoToVRMLAction_isVerbose(SoToVRMLAction self) -> SbBool"},
	 { "SoToVRMLAction_swigregister", SoToVRMLAction_swigregister, METH_O, NULL},
	 { "SoToVRMLAction_swiginit", SoToVRMLAction_swiginit, METH_VARARGS, NULL},
	 { "SoToVRML2Action_getTypeId", _wrap_SoToVRML2Action_getTypeId, METH_O, "SoToVRML2Action_getTypeId(SoToVRML2Action self) -> SoType"},
	 { "SoToVRML2Action_getClassTypeId", _wrap_SoToVRML2Action_getClassTypeId, METH_NOARGS, "SoToVRML2Action_getClassTypeId() -> SoType"},
	 { "SoToVRML2Action_addMethod", _wrap_SoToVRML2Action_addMethod, METH_VARARGS, "SoToVRML2Action_addMethod(SoType type, SoActionMethod method)"},
	 { "SoToVRML2Action_enableElement", _wrap_SoToVRML2Action_enableElement, METH_VARARGS, "SoToVRML2Action_enableElement(SoType type, int const stackindex)"},
	 { "SoToVRML2Action_initClass", _wrap_SoToVRML2Action_initClass, METH_NOARGS, "SoToVRML2Action_initClass()"},
	 { "new_SoToVRML2Action", _wrap_new_SoToVRML2Action, METH_NOARGS, "new_SoToVRML2Action() -> SoToVRML2Action"},
	 { "delete_SoToVRML2Action", _wrap_delete_SoToVRML2Action, METH_O, "delete_SoToVRML2Action(SoToVRML2Action self)"},
	 { "SoToVRML2Action_apply", _wrap_SoToVRML2Action_apply, METH_VARARGS, "\n"
		"SoToVRML2Action_apply(SoToVRML2Action self, SoNode node)\n"
		"SoToVRML2Action_apply(SoToVRML2Action self, SoPath path)\n"
		"SoToVRML2Action_apply(SoToVRML2Action self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoToVRML2Action_getVRML2SceneGraph", _wrap_SoToVRML2Action_getVRML2SceneGraph, METH_O, "SoToVRML2Action_getVRML2SceneGraph(SoToVRML2Action self) -> SoVRMLGroup"},
	 { "SoToVRML2Action_reuseAppearanceNodes", _wrap_SoToVRML2Action_reuseAppearanceNodes, METH_VARARGS, "SoToVRML2Action_reuseAppearanceNodes(SoToVRML2Action self, SbBool appearance)"},
	 { "SoToVRML2Action_doReuseAppearanceNodes", _wrap_SoToVRML2Action_doReuseAppearanceNodes, METH_O, "SoToVRML2Action_doReuseAppearanceNodes(SoToVRML2Action self) -> SbBool"},
	 { "SoToVRML2Action_reusePropertyNodes", _wrap_SoToVRML2Action_reusePropertyNodes, METH_VARARGS, "SoToVRML2Action_reusePropertyNodes(SoToVRML2Action self, SbBool property)"},
	 { "SoToVRML2Action_doReusePropertyNodes", _wrap_SoToVRML2Action_doReusePropertyNodes, METH_O, "SoToVRML2Action_doReusePropertyNodes(SoToVRML2Action self) -> SbBool"},
	 { "SoToVRML2Action_reuseGeometryNodes", _wrap_SoToVRML2Action_reuseGeometryNodes, METH_VARARGS, "SoToVRML2Action_reuseGeometryNodes(SoToVRML2Action self, SbBool geometry)"},
	 { "SoToVRML2Action_doReuseGeometryNodes", _wrap_SoToVRML2Action_doReuseGeometryNodes, METH_O, "SoToVRML2Action_doReuseGeometryNodes(SoToVRML2Action self) -> SbBool"},
	 { "SoToVRML2Action_swigregister", SoToVRML2Action_swigregister, METH_O, NULL},
	 { "SoToVRML2Action_swiginit", SoToVRML2Action_swiginit, METH_VARARGS, NULL},
	 { "SoHardCopy_init", _wrap_SoHardCopy_init, METH_NOARGS, "SoHardCopy_init()"},
	 { "SoHardCopy_getProductName", _wrap_SoHardCopy_getProductName, METH_NOARGS, "SoHardCopy_getProductName() -> char const *"},
	 { "SoHardCopy_getVersion", _wrap_SoHardCopy_getVersion, METH_NOARGS, "SoHardCopy_getVersion() -> char const *"},
	 { "new_SoHardCopy", _wrap_new_SoHardCopy, METH_NOARGS, "new_SoHardCopy() -> SoHardCopy"},
	 { "delete_SoHardCopy", _wrap_delete_SoHardCopy, METH_O, "delete_SoHardCopy(SoHardCopy self)"},
	 { "SoHardCopy_swigregister", SoHardCopy_swigregister, METH_O, NULL},
	 { "SoHardCopy_swiginit", SoHardCopy_swiginit, METH_VARARGS, NULL},
	 { "new_SoVectorOutput", _wrap_new_SoVectorOutput, METH_NOARGS, "new_SoVectorOutput() -> SoVectorOutput"},
	 { "delete_SoVectorOutput", _wrap_delete_SoVectorOutput, METH_O, "delete_SoVectorOutput(SoVectorOutput self)"},
	 { "SoVectorOutput_openFile", _wrap_SoVectorOutput_openFile, METH_VARARGS, "SoVectorOutput_openFile(SoVectorOutput self, char const * filename) -> SbBool"},
	 { "SoVectorOutput_closeFile", _wrap_SoVectorOutput_closeFile, METH_O, "SoVectorOutput_closeFile(SoVectorOutput self)"},
	 { "SoVectorOutput_getFilePointer", _wrap_SoVectorOutput_getFilePointer, METH_O, "SoVectorOutput_getFilePointer(SoVectorOutput self) -> FILE *"},
	 { "SoVectorOutput_swigregister", SoVectorOutput_swigregister, METH_O, NULL},
	 { "SoVectorOutput_swiginit", SoVectorOutput_swiginit, METH_VARARGS, NULL},
	 { "new_SoPSVectorOutput", _wrap_new_SoPSVectorOutput, METH_NOARGS, "new_SoPSVectorOutput() -> SoPSVectorOutput"},
	 { "delete_SoPSVectorOutput", _wrap_delete_SoPSVectorOutput, METH_O, "delete_SoPSVectorOutput(SoPSVectorOutput self)"},
	 { "SoPSVectorOutput_setColored", _wrap_SoPSVectorOutput_setColored, METH_VARARGS, "SoPSVectorOutput_setColored(SoPSVectorOutput self, SbBool flag=1)"},
	 { "SoPSVectorOutput_getColored", _wrap_SoPSVectorOutput_getColored, METH_O, "SoPSVectorOutput_getColored(SoPSVectorOutput self) -> SbBool"},
	 { "SoPSVectorOutput_swigregister", SoPSVectorOutput_swigregister, METH_O, NULL},
	 { "SoPSVectorOutput_swiginit", SoPSVectorOutput_swiginit, METH_VARARGS, NULL},
	 { "SoVectorizeAction_getTypeId", _wrap_SoVectorizeAction_getTypeId, METH_O, "SoVectorizeAction_getTypeId(SoVectorizeAction self) -> SoType"},
	 { "SoVectorizeAction_getClassTypeId", _wrap_SoVectorizeAction_getClassTypeId, METH_NOARGS, "SoVectorizeAction_getClassTypeId() -> SoType"},
	 { "SoVectorizeAction_addMethod", _wrap_SoVectorizeAction_addMethod, METH_VARARGS, "SoVectorizeAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoVectorizeAction_enableElement", _wrap_SoVectorizeAction_enableElement, METH_VARARGS, "SoVectorizeAction_enableElement(SoType type, int const stackindex)"},
	 { "delete_SoVectorizeAction", _wrap_delete_SoVectorizeAction, METH_O, "delete_SoVectorizeAction(SoVectorizeAction self)"},
	 { "SoVectorizeAction_getOutput", _wrap_SoVectorizeAction_getOutput, METH_O, "SoVectorizeAction_getOutput(SoVectorizeAction self) -> SoVectorOutput"},
	 { "SoVectorizeAction_initClass", _wrap_SoVectorizeAction_initClass, METH_NOARGS, "SoVectorizeAction_initClass()"},
	 { "SoVectorizeAction_apply", _wrap_SoVectorizeAction_apply, METH_VARARGS, "\n"
		"SoVectorizeAction_apply(SoVectorizeAction self, SoNode node)\n"
		"SoVectorizeAction_apply(SoVectorizeAction self, SoPath path)\n"
		"SoVectorizeAction_apply(SoVectorizeAction self, SoPathList pathlist, SbBool obeysrules=0)\n"
		""},
	 { "SoVectorizeAction_beginStandardPage", _wrap_SoVectorizeAction_beginStandardPage, METH_VARARGS, "SoVectorizeAction_beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize, float const border=10.0)"},
	 { "SoVectorizeAction_beginPage", _wrap_SoVectorizeAction_beginPage, METH_VARARGS, "SoVectorizeAction_beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize, SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_endPage", _wrap_SoVectorizeAction_endPage, METH_O, "SoVectorizeAction_endPage(SoVectorizeAction self)"},
	 { "SoVectorizeAction_calibrate", _wrap_SoVectorizeAction_calibrate, METH_VARARGS, "SoVectorizeAction_calibrate(SoVectorizeAction self, SbViewportRegion vp)"},
	 { "SoVectorizeAction_beginViewport", _wrap_SoVectorizeAction_beginViewport, METH_VARARGS, "SoVectorizeAction_beginViewport(SoVectorizeAction self, SbVec2f startpos=SbVec2f(-1.0f, 1.0f), SbVec2f size=SbVec2f(-1.0f, -1.0f), SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_endViewport", _wrap_SoVectorizeAction_endViewport, METH_O, "SoVectorizeAction_endViewport(SoVectorizeAction self)"},
	 { "SoVectorizeAction_setOrientation", _wrap_SoVectorizeAction_setOrientation, METH_VARARGS, "SoVectorizeAction_setOrientation(SoVectorizeAction self, SoVectorizeAction::Orientation o)"},
	 { "SoVectorizeAction_getOrientation", _wrap_SoVectorizeAction_getOrientation, METH_O, "SoVectorizeAction_getOrientation(SoVectorizeAction self) -> SoVectorizeAction::Orientation"},
	 { "SoVectorizeAction_setBackgroundColor", _wrap_SoVectorizeAction_setBackgroundColor, METH_VARARGS, "SoVectorizeAction_setBackgroundColor(SoVectorizeAction self, SbBool bg, SbColor col=SbColor(0.0f, 0.0f, 0.0f))"},
	 { "SoVectorizeAction_getBackgroundColor", _wrap_SoVectorizeAction_getBackgroundColor, METH_VARARGS, "SoVectorizeAction_getBackgroundColor(SoVectorizeAction self, SbColor col) -> SbBool"},
	 { "SoVectorizeAction_setNominalWidth", _wrap_SoVectorizeAction_setNominalWidth, METH_VARARGS, "SoVectorizeAction_setNominalWidth(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_getNominalWidth", _wrap_SoVectorizeAction_getNominalWidth, METH_VARARGS, "SoVectorizeAction_getNominalWidth(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"},
	 { "SoVectorizeAction_setPixelImageSize", _wrap_SoVectorizeAction_setPixelImageSize, METH_VARARGS, "SoVectorizeAction_setPixelImageSize(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_getPixelImageSize", _wrap_SoVectorizeAction_getPixelImageSize, METH_VARARGS, "SoVectorizeAction_getPixelImageSize(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"},
	 { "SoVectorizeAction_setPointStyle", _wrap_SoVectorizeAction_setPointStyle, METH_VARARGS, "SoVectorizeAction_setPointStyle(SoVectorizeAction self, SoVectorizeAction::PointStyle const & style)"},
	 { "SoVectorizeAction_getPointStyle", _wrap_SoVectorizeAction_getPointStyle, METH_O, "SoVectorizeAction_getPointStyle(SoVectorizeAction self) -> SoVectorizeAction::PointStyle"},
	 { "SoVectorizeAction_getPageStartpos", _wrap_SoVectorizeAction_getPageStartpos, METH_O, "SoVectorizeAction_getPageStartpos(SoVectorizeAction self) -> SbVec2f"},
	 { "SoVectorizeAction_getPageSize", _wrap_SoVectorizeAction_getPageSize, METH_O, "SoVectorizeAction_getPageSize(SoVectorizeAction self) -> SbVec2f"},
	 { "SoVectorizeAction_setDrawingDimensions", _wrap_SoVectorizeAction_setDrawingDimensions, METH_VARARGS, "\n"
		"SoVectorizeAction_setDrawingDimensions(SoVectorizeAction self, SbVec2f d, SoVectorizeAction::DimensionUnit u=MM)\n"
		"SoVectorizeAction_setDrawingDimensions(SoVectorizeAction self, float w, float h, SoVectorizeAction::DimensionUnit u=MM)\n"
		""},
	 { "SoVectorizeAction_getDrawingDimensions", _wrap_SoVectorizeAction_getDrawingDimensions, METH_VARARGS, "SoVectorizeAction_getDrawingDimensions(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"},
	 { "SoVectorizeAction_setStartPosition", _wrap_SoVectorizeAction_setStartPosition, METH_VARARGS, "\n"
		"SoVectorizeAction_setStartPosition(SoVectorizeAction self, SbVec2f p, SoVectorizeAction::DimensionUnit u=MM)\n"
		"SoVectorizeAction_setStartPosition(SoVectorizeAction self, float x, float y, SoVectorizeAction::DimensionUnit u=MM)\n"
		""},
	 { "SoVectorizeAction_getStartPosition", _wrap_SoVectorizeAction_getStartPosition, METH_VARARGS, "SoVectorizeAction_getStartPosition(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"},
	 { "SoVectorizeAction_setColorTranslationMethod", _wrap_SoVectorizeAction_setColorTranslationMethod, METH_VARARGS, "SoVectorizeAction_setColorTranslationMethod(SoVectorizeAction self, SoVectorizeAction::ColorTranslationMethod method)"},
	 { "SoVectorizeAction_getColorTranslationMethod", _wrap_SoVectorizeAction_getColorTranslationMethod, METH_O, "SoVectorizeAction_getColorTranslationMethod(SoVectorizeAction self) -> SoVectorizeAction::ColorTranslationMethod"},
	 { "SoVectorizeAction_setLineEndStyle", _wrap_SoVectorizeAction_setLineEndStyle, METH_VARARGS, "SoVectorizeAction_setLineEndStyle(SoVectorizeAction self, SoVectorizeAction::EndLineStyle style)"},
	 { "SoVectorizeAction_getLineEndStyle", _wrap_SoVectorizeAction_getLineEndStyle, METH_O, "SoVectorizeAction_getLineEndStyle(SoVectorizeAction self) -> SoVectorizeAction::EndLineStyle"},
	 { "SoVectorizeAction_setLineJoinsStyle", _wrap_SoVectorizeAction_setLineJoinsStyle, METH_VARARGS, "SoVectorizeAction_setLineJoinsStyle(SoVectorizeAction self, SoVectorizeAction::JoinLineStyle style)"},
	 { "SoVectorizeAction_getLineJoinsStyle", _wrap_SoVectorizeAction_getLineJoinsStyle, METH_O, "SoVectorizeAction_getLineJoinsStyle(SoVectorizeAction self) -> SoVectorizeAction::JoinLineStyle"},
	 { "SoVectorizeAction_setHLHSRMode", _wrap_SoVectorizeAction_setHLHSRMode, METH_VARARGS, "SoVectorizeAction_setHLHSRMode(SoVectorizeAction self, SoVectorizeAction::HLHSRMode mode)"},
	 { "SoVectorizeAction_getHLHSRMode", _wrap_SoVectorizeAction_getHLHSRMode, METH_O, "SoVectorizeAction_getHLHSRMode(SoVectorizeAction self) -> SoVectorizeAction::HLHSRMode"},
	 { "SoVectorizeAction_setBorder", _wrap_SoVectorizeAction_setBorder, METH_VARARGS, "\n"
		"SoVectorizeAction_setBorder(SoVectorizeAction self, float width)\n"
		"SoVectorizeAction_setBorder(SoVectorizeAction self, float width, SbColor color)\n"
		""},
	 { "SoVectorizeAction_setMiterLimit", _wrap_SoVectorizeAction_setMiterLimit, METH_VARARGS, "SoVectorizeAction_setMiterLimit(SoVectorizeAction self, float limit)"},
	 { "SoVectorizeAction_getMiterLimit", _wrap_SoVectorizeAction_getMiterLimit, METH_O, "SoVectorizeAction_getMiterLimit(SoVectorizeAction self) -> float"},
	 { "SoVectorizeAction_setPenDescription", _wrap_SoVectorizeAction_setPenDescription, METH_VARARGS, "SoVectorizeAction_setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None, SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_getPenDescription", _wrap_SoVectorizeAction_getPenDescription, METH_VARARGS, "SoVectorizeAction_getPenDescription(SoVectorizeAction self, SbColor colors, float * widths, SoVectorizeAction::DimensionUnit u=MM)"},
	 { "SoVectorizeAction_getPenNum", _wrap_SoVectorizeAction_getPenNum, METH_O, "SoVectorizeAction_getPenNum(SoVectorizeAction self) -> int"},
	 { "SoVectorizeAction_setColorPriority", _wrap_SoVectorizeAction_setColorPriority, METH_VARARGS, "SoVectorizeAction_setColorPriority(SoVectorizeAction self, SbBool priority)"},
	 { "SoVectorizeAction_getColorPriority", _wrap_SoVectorizeAction_getColorPriority, METH_O, "SoVectorizeAction_getColorPriority(SoVectorizeAction self) -> SbBool"},
	 { "SoVectorizeAction_enableLighting", _wrap_SoVectorizeAction_enableLighting, METH_VARARGS, "SoVectorizeAction_enableLighting(SoVectorizeAction self, SbBool flag)"},
	 { "SoVectorizeAction_isLightingEnabled", _wrap_SoVectorizeAction_isLightingEnabled, METH_O, "SoVectorizeAction_isLightingEnabled(SoVectorizeAction self) -> SbBool"},
	 { "SoVectorizeAction_swigregister", SoVectorizeAction_swigregister, METH_O, NULL},
	 { "SoMultiTextureCoordinateElement_getClassTypeId", _wrap_SoMultiTextureCoordinateElement_getClassTypeId, METH_NOARGS, "SoMultiTextureCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoMultiTextureCoordinateElement_getClassStackIndex", _wrap_SoMultiTextureCoordinateElement_getClassStackIndex, METH_NOARGS, "SoMultiTextureCoordinateElement_getClassStackIndex() -> int"},
	 { "SoMultiTextureCoordinateElement_createInstance", _wrap_SoMultiTextureCoordinateElement_createInstance, METH_NOARGS, "SoMultiTextureCoordinateElement_createInstance() -> void *"},
	 { "SoMultiTextureCoordinateElement_initClass", _wrap_SoMultiTextureCoordinateElement_initClass, METH_NOARGS, "SoMultiTextureCoordinateElement_initClass()"},
	 { "SoMultiTextureCoordinateElement_init", _wrap_SoMultiTextureCoordinateElement_init, METH_VARARGS, "SoMultiTextureCoordinateElement_init(SoMultiTextureCoordinateElement self, SoState state)"},
	 { "SoMultiTextureCoordinateElement_setDefault", _wrap_SoMultiTextureCoordinateElement_setDefault, METH_VARARGS, "SoMultiTextureCoordinateElement_setDefault(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureCoordinateElement_getType", _wrap_SoMultiTextureCoordinateElement_getType, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_getType(SoMultiTextureCoordinateElement self, SoState state, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType\n"
		"SoMultiTextureCoordinateElement_getType(SoMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType\n"
		""},
	 { "SoMultiTextureCoordinateElement_getInstance", _wrap_SoMultiTextureCoordinateElement_getInstance, METH_O, "SoMultiTextureCoordinateElement_getInstance(SoState state) -> SoMultiTextureCoordinateElement"},
	 { "SoMultiTextureCoordinateElement_getNum", _wrap_SoMultiTextureCoordinateElement_getNum, METH_VARARGS, "SoMultiTextureCoordinateElement_getNum(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t"},
	 { "SoMultiTextureCoordinateElement_is2D", _wrap_SoMultiTextureCoordinateElement_is2D, METH_VARARGS, "SoMultiTextureCoordinateElement_is2D(SoMultiTextureCoordinateElement self, int const unit=0) -> SbBool"},
	 { "SoMultiTextureCoordinateElement_getDimension", _wrap_SoMultiTextureCoordinateElement_getDimension, METH_VARARGS, "SoMultiTextureCoordinateElement_getDimension(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t"},
	 { "SoMultiTextureCoordinateElement_getArrayPtr2", _wrap_SoMultiTextureCoordinateElement_getArrayPtr2, METH_VARARGS, "SoMultiTextureCoordinateElement_getArrayPtr2(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec2f"},
	 { "SoMultiTextureCoordinateElement_getArrayPtr3", _wrap_SoMultiTextureCoordinateElement_getArrayPtr3, METH_VARARGS, "SoMultiTextureCoordinateElement_getArrayPtr3(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec3f"},
	 { "SoMultiTextureCoordinateElement_getArrayPtr4", _wrap_SoMultiTextureCoordinateElement_getArrayPtr4, METH_VARARGS, "SoMultiTextureCoordinateElement_getArrayPtr4(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec4f"},
	 { "SoMultiTextureCoordinateElement_push", _wrap_SoMultiTextureCoordinateElement_push, METH_VARARGS, "SoMultiTextureCoordinateElement_push(SoMultiTextureCoordinateElement self, SoState state)"},
	 { "SoMultiTextureCoordinateElement_matches", _wrap_SoMultiTextureCoordinateElement_matches, METH_VARARGS, "SoMultiTextureCoordinateElement_matches(SoMultiTextureCoordinateElement self, SoElement elem) -> SbBool"},
	 { "SoMultiTextureCoordinateElement_copyMatchInfo", _wrap_SoMultiTextureCoordinateElement_copyMatchInfo, METH_O, "SoMultiTextureCoordinateElement_copyMatchInfo(SoMultiTextureCoordinateElement self) -> SoElement"},
	 { "SoMultiTextureCoordinateElement_get", _wrap_SoMultiTextureCoordinateElement_get, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_get(SoMultiTextureCoordinateElement self, int const unit, SbVec3f point, SbVec3f normal) -> SbVec4f\n"
		"SoMultiTextureCoordinateElement_get(SoMultiTextureCoordinateElement self, SbVec3f point, SbVec3f normal) -> SbVec4f\n"
		""},
	 { "SoMultiTextureCoordinateElement_set2", _wrap_SoMultiTextureCoordinateElement_set2, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)\n"
		"SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)\n"
		""},
	 { "SoMultiTextureCoordinateElement_set3", _wrap_SoMultiTextureCoordinateElement_set3, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)\n"
		"SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)\n"
		""},
	 { "SoMultiTextureCoordinateElement_set4", _wrap_SoMultiTextureCoordinateElement_set4, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)\n"
		"SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)\n"
		""},
	 { "SoMultiTextureCoordinateElement_get2", _wrap_SoMultiTextureCoordinateElement_get2, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_get2(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec2f\n"
		"SoMultiTextureCoordinateElement_get2(SoMultiTextureCoordinateElement self, int const index) -> SbVec2f\n"
		""},
	 { "SoMultiTextureCoordinateElement_get3", _wrap_SoMultiTextureCoordinateElement_get3, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_get3(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec3f\n"
		"SoMultiTextureCoordinateElement_get3(SoMultiTextureCoordinateElement self, int const index) -> SbVec3f\n"
		""},
	 { "SoMultiTextureCoordinateElement_get4", _wrap_SoMultiTextureCoordinateElement_get4, METH_VARARGS, "\n"
		"SoMultiTextureCoordinateElement_get4(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec4f\n"
		"SoMultiTextureCoordinateElement_get4(SoMultiTextureCoordinateElement self, int const index) -> SbVec4f\n"
		""},
	 { "SoMultiTextureCoordinateElement_swigregister", SoMultiTextureCoordinateElement_swigregister, METH_O, NULL},
	 { "SoShape_getClassTypeId", _wrap_SoShape_getClassTypeId, METH_NOARGS, "SoShape_getClassTypeId() -> SoType"},
	 { "SoShape_getTypeId", _wrap_SoShape_getTypeId, METH_O, "SoShape_getTypeId(SoShape self) -> SoType"},
	 { "SoShape_initClass", _wrap_SoShape_initClass, METH_NOARGS, "SoShape_initClass()"},
	 { "SoShape_affectsState", _wrap_SoShape_affectsState, METH_O, "SoShape_affectsState(SoShape self) -> SbBool"},
	 { "SoShape_notify", _wrap_SoShape_notify, METH_VARARGS, "SoShape_notify(SoShape self, SoNotList nl)"},
	 { "SoShape_getBoundingBox", _wrap_SoShape_getBoundingBox, METH_VARARGS, "SoShape_getBoundingBox(SoShape self, SoGetBoundingBoxAction action)"},
	 { "SoShape_GLRender", _wrap_SoShape_GLRender, METH_VARARGS, "SoShape_GLRender(SoShape self, SoGLRenderAction action)"},
	 { "SoShape_rayPick", _wrap_SoShape_rayPick, METH_VARARGS, "SoShape_rayPick(SoShape self, SoRayPickAction action)"},
	 { "SoShape_callback", _wrap_SoShape_callback, METH_VARARGS, "SoShape_callback(SoShape self, SoCallbackAction action)"},
	 { "SoShape_computeBBox", _wrap_SoShape_computeBBox, METH_VARARGS, "SoShape_computeBBox(SoShape self, SoAction action, SbBox3f box, SbVec3f center)"},
	 { "SoShape_getPrimitiveCount", _wrap_SoShape_getPrimitiveCount, METH_VARARGS, "SoShape_getPrimitiveCount(SoShape self, SoGetPrimitiveCountAction action)"},
	 { "SoShape_getScreenSize", _wrap_SoShape_getScreenSize, METH_VARARGS, "SoShape_getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"},
	 { "SoShape_getDecimatedComplexity", _wrap_SoShape_getDecimatedComplexity, METH_VARARGS, "SoShape_getDecimatedComplexity(SoState state, float complexity) -> float"},
	 { "SoShape_getBoundingBoxCache", _wrap_SoShape_getBoundingBoxCache, METH_O, "SoShape_getBoundingBoxCache(SoShape self) -> SoBoundingBoxCache"},
	 { "SoShape_swigregister", SoShape_swigregister, METH_O, NULL},
	 { "SoImage_getClassTypeId", _wrap_SoImage_getClassTypeId, METH_NOARGS, "SoImage_getClassTypeId() -> SoType"},
	 { "SoImage_getTypeId", _wrap_SoImage_getTypeId, METH_O, "SoImage_getTypeId(SoImage self) -> SoType"},
	 { "SoImage_initClass", _wrap_SoImage_initClass, METH_NOARGS, "SoImage_initClass()"},
	 { "new_SoImage", _wrap_new_SoImage, METH_NOARGS, "new_SoImage() -> SoImage"},
	 { "SoImage_width_set", _wrap_SoImage_width_set, METH_VARARGS, "SoImage_width_set(SoImage self, SoSFInt32 width)"},
	 { "SoImage_width_get", _wrap_SoImage_width_get, METH_O, "SoImage_width_get(SoImage self) -> SoSFInt32"},
	 { "SoImage_height_set", _wrap_SoImage_height_set, METH_VARARGS, "SoImage_height_set(SoImage self, SoSFInt32 height)"},
	 { "SoImage_height_get", _wrap_SoImage_height_get, METH_O, "SoImage_height_get(SoImage self) -> SoSFInt32"},
	 { "SoImage_vertAlignment_set", _wrap_SoImage_vertAlignment_set, METH_VARARGS, "SoImage_vertAlignment_set(SoImage self, SoSFEnum vertAlignment)"},
	 { "SoImage_vertAlignment_get", _wrap_SoImage_vertAlignment_get, METH_O, "SoImage_vertAlignment_get(SoImage self) -> SoSFEnum"},
	 { "SoImage_horAlignment_set", _wrap_SoImage_horAlignment_set, METH_VARARGS, "SoImage_horAlignment_set(SoImage self, SoSFEnum horAlignment)"},
	 { "SoImage_horAlignment_get", _wrap_SoImage_horAlignment_get, METH_O, "SoImage_horAlignment_get(SoImage self) -> SoSFEnum"},
	 { "SoImage_image_set", _wrap_SoImage_image_set, METH_VARARGS, "SoImage_image_set(SoImage self, SoSFImage image)"},
	 { "SoImage_image_get", _wrap_SoImage_image_get, METH_O, "SoImage_image_get(SoImage self) -> SoSFImage"},
	 { "SoImage_filename_set", _wrap_SoImage_filename_set, METH_VARARGS, "SoImage_filename_set(SoImage self, SoSFString filename)"},
	 { "SoImage_filename_get", _wrap_SoImage_filename_get, METH_O, "SoImage_filename_get(SoImage self) -> SoSFString"},
	 { "SoImage_GLRender", _wrap_SoImage_GLRender, METH_VARARGS, "SoImage_GLRender(SoImage self, SoGLRenderAction action)"},
	 { "SoImage_rayPick", _wrap_SoImage_rayPick, METH_VARARGS, "SoImage_rayPick(SoImage self, SoRayPickAction action)"},
	 { "SoImage_getPrimitiveCount", _wrap_SoImage_getPrimitiveCount, METH_VARARGS, "SoImage_getPrimitiveCount(SoImage self, SoGetPrimitiveCountAction action)"},
	 { "SoImage_swigregister", SoImage_swigregister, METH_O, NULL},
	 { "SoImage_swiginit", SoImage_swiginit, METH_VARARGS, NULL},
	 { "SoVectorizePSAction_getTypeId", _wrap_SoVectorizePSAction_getTypeId, METH_O, "SoVectorizePSAction_getTypeId(SoVectorizePSAction self) -> SoType"},
	 { "SoVectorizePSAction_getClassTypeId", _wrap_SoVectorizePSAction_getClassTypeId, METH_NOARGS, "SoVectorizePSAction_getClassTypeId() -> SoType"},
	 { "SoVectorizePSAction_addMethod", _wrap_SoVectorizePSAction_addMethod, METH_VARARGS, "SoVectorizePSAction_addMethod(SoType type, SoActionMethod method)"},
	 { "SoVectorizePSAction_enableElement", _wrap_SoVectorizePSAction_enableElement, METH_VARARGS, "SoVectorizePSAction_enableElement(SoType type, int const stackindex)"},
	 { "new_SoVectorizePSAction", _wrap_new_SoVectorizePSAction, METH_NOARGS, "new_SoVectorizePSAction() -> SoVectorizePSAction"},
	 { "delete_SoVectorizePSAction", _wrap_delete_SoVectorizePSAction, METH_O, "delete_SoVectorizePSAction(SoVectorizePSAction self)"},
	 { "SoVectorizePSAction_initClass", _wrap_SoVectorizePSAction_initClass, METH_NOARGS, "SoVectorizePSAction_initClass()"},
	 { "SoVectorizePSAction_setDefault2DFont", _wrap_SoVectorizePSAction_setDefault2DFont, METH_VARARGS, "SoVectorizePSAction_setDefault2DFont(SoVectorizePSAction self, SbString fontname)"},
	 { "SoVectorizePSAction_getDefault2DFont", _wrap_SoVectorizePSAction_getDefault2DFont, METH_O, "SoVectorizePSAction_getDefault2DFont(SoVectorizePSAction self) -> SbString"},
	 { "SoVectorizePSAction_setGouraudThreshold", _wrap_SoVectorizePSAction_setGouraudThreshold, METH_VARARGS, "SoVectorizePSAction_setGouraudThreshold(SoVectorizePSAction self, double const eps)"},
	 { "SoVectorizePSAction_getOutput", _wrap_SoVectorizePSAction_getOutput, METH_O, "SoVectorizePSAction_getOutput(SoVectorizePSAction self) -> SoPSVectorOutput"},
	 { "SoVectorizePSAction_getPSOutput", _wrap_SoVectorizePSAction_getPSOutput, METH_O, "SoVectorizePSAction_getPSOutput(SoVectorizePSAction self) -> SoPSVectorOutput"},
	 { "SoVectorizePSAction_swigregister", SoVectorizePSAction_swigregister, METH_O, NULL},
	 { "SoVectorizePSAction_swiginit", SoVectorizePSAction_swiginit, METH_VARARGS, NULL},
	 { "SoBundle_swigregister", SoBundle_swigregister, METH_O, NULL},
	 { "new_SoMaterialBundle", _wrap_new_SoMaterialBundle, METH_O, "new_SoMaterialBundle(SoAction action) -> SoMaterialBundle"},
	 { "delete_SoMaterialBundle", _wrap_delete_SoMaterialBundle, METH_O, "delete_SoMaterialBundle(SoMaterialBundle self)"},
	 { "SoMaterialBundle_setUpMultiple", _wrap_SoMaterialBundle_setUpMultiple, METH_O, "SoMaterialBundle_setUpMultiple(SoMaterialBundle self)"},
	 { "SoMaterialBundle_sendFirst", _wrap_SoMaterialBundle_sendFirst, METH_O, "SoMaterialBundle_sendFirst(SoMaterialBundle self)"},
	 { "SoMaterialBundle_forceSend", _wrap_SoMaterialBundle_forceSend, METH_VARARGS, "SoMaterialBundle_forceSend(SoMaterialBundle self, int const index)"},
	 { "SoMaterialBundle_isColorOnly", _wrap_SoMaterialBundle_isColorOnly, METH_O, "SoMaterialBundle_isColorOnly(SoMaterialBundle self) -> SbBool"},
	 { "SoMaterialBundle_send", _wrap_SoMaterialBundle_send, METH_VARARGS, "SoMaterialBundle_send(SoMaterialBundle self, int const index, SbBool const betweenbeginend)"},
	 { "SoMaterialBundle_swigregister", SoMaterialBundle_swigregister, METH_O, NULL},
	 { "SoMaterialBundle_swiginit", SoMaterialBundle_swiginit, METH_VARARGS, NULL},
	 { "new_SbBSPTree", _wrap_new_SbBSPTree, METH_VARARGS, "SbBSPTree(int const maxnodepts=64, int const initsize=4)"},
	 { "delete_SbBSPTree", _wrap_delete_SbBSPTree, METH_O, "delete_SbBSPTree(SbBSPTree self)"},
	 { "SbBSPTree_numPoints", _wrap_SbBSPTree_numPoints, METH_O, "SbBSPTree_numPoints(SbBSPTree self) -> int"},
	 { "SbBSPTree_getPoint", _wrap_SbBSPTree_getPoint, METH_VARARGS, "\n"
		"SbBSPTree_getPoint(SbBSPTree self, int const idx) -> SbVec3f\n"
		"SbBSPTree_getPoint(SbBSPTree self, int const idx, SbVec3f pt)\n"
		""},
	 { "SbBSPTree_getUserData", _wrap_SbBSPTree_getUserData, METH_VARARGS, "SbBSPTree_getUserData(SbBSPTree self, int const idx) -> void *"},
	 { "SbBSPTree_setUserData", _wrap_SbBSPTree_setUserData, METH_VARARGS, "SbBSPTree_setUserData(SbBSPTree self, int const idx, void *const data)"},
	 { "SbBSPTree_addPoint", _wrap_SbBSPTree_addPoint, METH_VARARGS, "SbBSPTree_addPoint(SbBSPTree self, SbVec3f pt, void *const userdata=None) -> int"},
	 { "SbBSPTree_removePoint", _wrap_SbBSPTree_removePoint, METH_VARARGS, "\n"
		"SbBSPTree_removePoint(SbBSPTree self, SbVec3f pt) -> int\n"
		"SbBSPTree_removePoint(SbBSPTree self, int const idx)\n"
		""},
	 { "SbBSPTree_findPoint", _wrap_SbBSPTree_findPoint, METH_VARARGS, "SbBSPTree_findPoint(SbBSPTree self, SbVec3f pos) -> int"},
	 { "SbBSPTree_clear", _wrap_SbBSPTree_clear, METH_VARARGS, "SbBSPTree_clear(SbBSPTree self, int const initsize=4)"},
	 { "SbBSPTree_getBBox", _wrap_SbBSPTree_getBBox, METH_O, "SbBSPTree_getBBox(SbBSPTree self) -> SbBox3f"},
	 { "SbBSPTree_getPointsArrayPtr", _wrap_SbBSPTree_getPointsArrayPtr, METH_O, "SbBSPTree_getPointsArrayPtr(SbBSPTree self) -> SbVec3f"},
	 { "SbBSPTree_findPoints", _wrap_SbBSPTree_findPoints, METH_VARARGS, "\n"
		"SbBSPTree_findPoints(SbBSPTree self, SbSphere sphere, SbIntList array)\n"
		"SbBSPTree_findPoints(SbBSPTree self, SbSphere sphere, SbList< int > & array)\n"
		""},
	 { "SbBSPTree_findClosest", _wrap_SbBSPTree_findClosest, METH_VARARGS, "\n"
		"SbBSPTree_findClosest(SbBSPTree self, SbVec3f pos) -> int\n"
		"SbBSPTree_findClosest(SbBSPTree self, SbSphere sphere, SbIntList array) -> int\n"
		"SbBSPTree_findClosest(SbBSPTree self, SbSphere sphere, SbList< int > & array) -> int\n"
		""},
	 { "SbBSPTree_swigregister", SbBSPTree_swigregister, METH_O, NULL},
	 { "SbBSPTree_swiginit", SbBSPTree_swiginit, METH_VARARGS, NULL},
	 { "new_SoNormalGenerator", _wrap_new_SoNormalGenerator, METH_VARARGS, "SoNormalGenerator(SbBool const ccw, int const approxVertices=64)"},
	 { "delete_SoNormalGenerator", _wrap_delete_SoNormalGenerator, METH_O, "delete_SoNormalGenerator(SoNormalGenerator self)"},
	 { "SoNormalGenerator_reset", _wrap_SoNormalGenerator_reset, METH_VARARGS, "SoNormalGenerator_reset(SoNormalGenerator self, SbBool const ccw)"},
	 { "SoNormalGenerator_beginPolygon", _wrap_SoNormalGenerator_beginPolygon, METH_O, "SoNormalGenerator_beginPolygon(SoNormalGenerator self)"},
	 { "SoNormalGenerator_polygonVertex", _wrap_SoNormalGenerator_polygonVertex, METH_VARARGS, "SoNormalGenerator_polygonVertex(SoNormalGenerator self, SbVec3f v)"},
	 { "SoNormalGenerator_endPolygon", _wrap_SoNormalGenerator_endPolygon, METH_O, "SoNormalGenerator_endPolygon(SoNormalGenerator self)"},
	 { "SoNormalGenerator_triangle", _wrap_SoNormalGenerator_triangle, METH_VARARGS, "SoNormalGenerator_triangle(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"},
	 { "SoNormalGenerator_quad", _wrap_SoNormalGenerator_quad, METH_VARARGS, "SoNormalGenerator_quad(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f v3)"},
	 { "SoNormalGenerator_generate", _wrap_SoNormalGenerator_generate, METH_VARARGS, "SoNormalGenerator_generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None, int const numstrips=0)"},
	 { "SoNormalGenerator_generatePerStrip", _wrap_SoNormalGenerator_generatePerStrip, METH_VARARGS, "SoNormalGenerator_generatePerStrip(SoNormalGenerator self, int32_t const * striplens, int const numstrips)"},
	 { "SoNormalGenerator_generatePerFace", _wrap_SoNormalGenerator_generatePerFace, METH_O, "SoNormalGenerator_generatePerFace(SoNormalGenerator self)"},
	 { "SoNormalGenerator_generateOverall", _wrap_SoNormalGenerator_generateOverall, METH_O, "SoNormalGenerator_generateOverall(SoNormalGenerator self)"},
	 { "SoNormalGenerator_getNumNormals", _wrap_SoNormalGenerator_getNumNormals, METH_O, "SoNormalGenerator_getNumNormals(SoNormalGenerator self) -> int"},
	 { "SoNormalGenerator_setNumNormals", _wrap_SoNormalGenerator_setNumNormals, METH_VARARGS, "SoNormalGenerator_setNumNormals(SoNormalGenerator self, int const num)"},
	 { "SoNormalGenerator_getNormals", _wrap_SoNormalGenerator_getNormals, METH_O, "SoNormalGenerator_getNormals(SoNormalGenerator self) -> SbVec3f"},
	 { "SoNormalGenerator_getNormal", _wrap_SoNormalGenerator_getNormal, METH_VARARGS, "SoNormalGenerator_getNormal(SoNormalGenerator self, int32_t const i) -> SbVec3f"},
	 { "SoNormalGenerator_setNormal", _wrap_SoNormalGenerator_setNormal, METH_VARARGS, "SoNormalGenerator_setNormal(SoNormalGenerator self, int32_t const index, SbVec3f normal)"},
	 { "SoNormalGenerator_swigregister", SoNormalGenerator_swigregister, METH_O, NULL},
	 { "SoNormalGenerator_swiginit", SoNormalGenerator_swiginit, METH_VARARGS, NULL},
	 { "SoNormalElement_getClassTypeId", _wrap_SoNormalElement_getClassTypeId, METH_NOARGS, "SoNormalElement_getClassTypeId() -> SoType"},
	 { "SoNormalElement_getClassStackIndex", _wrap_SoNormalElement_getClassStackIndex, METH_NOARGS, "SoNormalElement_getClassStackIndex() -> int"},
	 { "SoNormalElement_createInstance", _wrap_SoNormalElement_createInstance, METH_NOARGS, "SoNormalElement_createInstance() -> void *"},
	 { "SoNormalElement_initClass", _wrap_SoNormalElement_initClass, METH_NOARGS, "SoNormalElement_initClass()"},
	 { "SoNormalElement_init", _wrap_SoNormalElement_init, METH_VARARGS, "SoNormalElement_init(SoNormalElement self, SoState state)"},
	 { "SoNormalElement_set", _wrap_SoNormalElement_set, METH_VARARGS, "SoNormalElement_set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)"},
	 { "SoNormalElement_getInstance", _wrap_SoNormalElement_getInstance, METH_O, "SoNormalElement_getInstance(SoState state) -> SoNormalElement"},
	 { "SoNormalElement_getNum", _wrap_SoNormalElement_getNum, METH_O, "SoNormalElement_getNum(SoNormalElement self) -> int32_t"},
	 { "SoNormalElement_get", _wrap_SoNormalElement_get, METH_VARARGS, "SoNormalElement_get(SoNormalElement self, int const index) -> SbVec3f"},
	 { "SoNormalElement_getArrayPtr", _wrap_SoNormalElement_getArrayPtr, METH_O, "SoNormalElement_getArrayPtr(SoNormalElement self) -> SbVec3f"},
	 { "SoNormalElement_areNormalsUnitLength", _wrap_SoNormalElement_areNormalsUnitLength, METH_O, "SoNormalElement_areNormalsUnitLength(SoNormalElement self) -> SbBool"},
	 { "SoNormalElement_swigregister", SoNormalElement_swigregister, METH_O, NULL},
	 { "SoGLNormalElement_getClassTypeId", _wrap_SoGLNormalElement_getClassTypeId, METH_NOARGS, "SoGLNormalElement_getClassTypeId() -> SoType"},
	 { "SoGLNormalElement_getClassStackIndex", _wrap_SoGLNormalElement_getClassStackIndex, METH_NOARGS, "SoGLNormalElement_getClassStackIndex() -> int"},
	 { "SoGLNormalElement_createInstance", _wrap_SoGLNormalElement_createInstance, METH_NOARGS, "SoGLNormalElement_createInstance() -> void *"},
	 { "SoGLNormalElement_initClass", _wrap_SoGLNormalElement_initClass, METH_NOARGS, "SoGLNormalElement_initClass()"},
	 { "SoGLNormalElement_init", _wrap_SoGLNormalElement_init, METH_VARARGS, "SoGLNormalElement_init(SoGLNormalElement self, SoState state)"},
	 { "SoGLNormalElement_send", _wrap_SoGLNormalElement_send, METH_VARARGS, "SoGLNormalElement_send(SoGLNormalElement self, int const index)"},
	 { "SoGLNormalElement_swigregister", SoGLNormalElement_swigregister, METH_O, NULL},
	 { "SoNormalBundle_generator_set", _wrap_SoNormalBundle_generator_set, METH_VARARGS, "SoNormalBundle_generator_set(SoNormalBundle self, SoNormalGenerator generator)"},
	 { "SoNormalBundle_generator_get", _wrap_SoNormalBundle_generator_get, METH_O, "SoNormalBundle_generator_get(SoNormalBundle self) -> SoNormalGenerator"},
	 { "SoNormalBundle_swigregister", SoNormalBundle_swigregister, METH_O, NULL},
	 { "SoGLMultiTextureCoordinateElement_getClassTypeId", _wrap_SoGLMultiTextureCoordinateElement_getClassTypeId, METH_NOARGS, "SoGLMultiTextureCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoGLMultiTextureCoordinateElement_getClassStackIndex", _wrap_SoGLMultiTextureCoordinateElement_getClassStackIndex, METH_NOARGS, "SoGLMultiTextureCoordinateElement_getClassStackIndex() -> int"},
	 { "SoGLMultiTextureCoordinateElement_createInstance", _wrap_SoGLMultiTextureCoordinateElement_createInstance, METH_NOARGS, "SoGLMultiTextureCoordinateElement_createInstance() -> void *"},
	 { "SoGLMultiTextureCoordinateElement_initClass", _wrap_SoGLMultiTextureCoordinateElement_initClass, METH_NOARGS, "SoGLMultiTextureCoordinateElement_initClass()"},
	 { "SoGLMultiTextureCoordinateElement_init", _wrap_SoGLMultiTextureCoordinateElement_init, METH_VARARGS, "SoGLMultiTextureCoordinateElement_init(SoGLMultiTextureCoordinateElement self, SoState state)"},
	 { "SoGLMultiTextureCoordinateElement_push", _wrap_SoGLMultiTextureCoordinateElement_push, METH_VARARGS, "SoGLMultiTextureCoordinateElement_push(SoGLMultiTextureCoordinateElement self, SoState state)"},
	 { "SoGLMultiTextureCoordinateElement_pop", _wrap_SoGLMultiTextureCoordinateElement_pop, METH_VARARGS, "SoGLMultiTextureCoordinateElement_pop(SoGLMultiTextureCoordinateElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLMultiTextureCoordinateElement_getType", _wrap_SoGLMultiTextureCoordinateElement_getType, METH_VARARGS, "SoGLMultiTextureCoordinateElement_getType(SoGLMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType"},
	 { "SoGLMultiTextureCoordinateElement_getInstance", _wrap_SoGLMultiTextureCoordinateElement_getInstance, METH_O, "SoGLMultiTextureCoordinateElement_getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"},
	 { "SoGLMultiTextureCoordinateElement_initRender", _wrap_SoGLMultiTextureCoordinateElement_initRender, METH_VARARGS, "SoGLMultiTextureCoordinateElement_initRender(SoGLMultiTextureCoordinateElement self, SbBool const * enabled, int const maxenabled)"},
	 { "SoGLMultiTextureCoordinateElement_send", _wrap_SoGLMultiTextureCoordinateElement_send, METH_VARARGS, "\n"
		"SoGLMultiTextureCoordinateElement_send(SoGLMultiTextureCoordinateElement self, int const unit, int const index)\n"
		"SoGLMultiTextureCoordinateElement_send(SoGLMultiTextureCoordinateElement self, int const unit, int const index, SbVec3f c, SbVec3f n)\n"
		"SoGLMultiTextureCoordinateElement_send(SoGLMultiTextureCoordinateElement self, int const index)\n"
		"SoGLMultiTextureCoordinateElement_send(SoGLMultiTextureCoordinateElement self, int const index, SbVec3f c, SbVec3f n)\n"
		""},
	 { "SoGLMultiTextureCoordinateElement_initMulti", _wrap_SoGLMultiTextureCoordinateElement_initMulti, METH_VARARGS, "SoGLMultiTextureCoordinateElement_initMulti(SoGLMultiTextureCoordinateElement self, SoState state)"},
	 { "SoGLMultiTextureCoordinateElement_swigregister", SoGLMultiTextureCoordinateElement_swigregister, METH_O, NULL},
	 { "new_SoTextureCoordinateBundle", _wrap_new_SoTextureCoordinateBundle, METH_VARARGS, "SoTextureCoordinateBundle(SoAction action, SbBool const forRendering, SbBool const setUpDefault=1)"},
	 { "delete_SoTextureCoordinateBundle", _wrap_delete_SoTextureCoordinateBundle, METH_O, "delete_SoTextureCoordinateBundle(SoTextureCoordinateBundle self)"},
	 { "SoTextureCoordinateBundle_needCoordinates", _wrap_SoTextureCoordinateBundle_needCoordinates, METH_O, "SoTextureCoordinateBundle_needCoordinates(SoTextureCoordinateBundle self) -> SbBool"},
	 { "SoTextureCoordinateBundle_isFunction", _wrap_SoTextureCoordinateBundle_isFunction, METH_O, "SoTextureCoordinateBundle_isFunction(SoTextureCoordinateBundle self) -> SbBool"},
	 { "SoTextureCoordinateBundle_get", _wrap_SoTextureCoordinateBundle_get, METH_VARARGS, "\n"
		"SoTextureCoordinateBundle_get(SoTextureCoordinateBundle self, int const index) -> SbVec4f\n"
		"SoTextureCoordinateBundle_get(SoTextureCoordinateBundle self, SbVec3f point, SbVec3f normal) -> SbVec4f\n"
		""},
	 { "SoTextureCoordinateBundle_send", _wrap_SoTextureCoordinateBundle_send, METH_VARARGS, "\n"
		"SoTextureCoordinateBundle_send(SoTextureCoordinateBundle self, int const index)\n"
		"SoTextureCoordinateBundle_send(SoTextureCoordinateBundle self, int const index, SbVec3f point, SbVec3f normal)\n"
		""},
	 { "SoTextureCoordinateBundle_needIndices", _wrap_SoTextureCoordinateBundle_needIndices, METH_O, "SoTextureCoordinateBundle_needIndices(SoTextureCoordinateBundle self) -> SbBool"},
	 { "SoTextureCoordinateBundle_swigregister", SoTextureCoordinateBundle_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateBundle_swiginit", SoTextureCoordinateBundle_swiginit, METH_VARARGS, NULL},
	 { "new_SoCache", _wrap_new_SoCache, METH_O, "new_SoCache(SoState state) -> SoCache"},
	 { "SoCache_ref", _wrap_SoCache_ref, METH_O, "SoCache_ref(SoCache self)"},
	 { "SoCache_unref", _wrap_SoCache_unref, METH_VARARGS, "SoCache_unref(SoCache self, SoState state=None)"},
	 { "SoCache_addElement", _wrap_SoCache_addElement, METH_VARARGS, "SoCache_addElement(SoCache self, SoElement elem)"},
	 { "SoCache_addCacheDependency", _wrap_SoCache_addCacheDependency, METH_VARARGS, "SoCache_addCacheDependency(SoCache self, SoState state, SoCache cache)"},
	 { "SoCache_isValid", _wrap_SoCache_isValid, METH_VARARGS, "SoCache_isValid(SoCache self, SoState state) -> SbBool"},
	 { "SoCache_getInvalidElement", _wrap_SoCache_getInvalidElement, METH_VARARGS, "SoCache_getInvalidElement(SoCache self, SoState state) -> SoElement"},
	 { "SoCache_invalidate", _wrap_SoCache_invalidate, METH_O, "SoCache_invalidate(SoCache self)"},
	 { "SoCache_swigregister", SoCache_swigregister, METH_O, NULL},
	 { "SoCache_swiginit", SoCache_swiginit, METH_VARARGS, NULL},
	 { "new_SoBoundingBoxCache", _wrap_new_SoBoundingBoxCache, METH_O, "new_SoBoundingBoxCache(SoState state) -> SoBoundingBoxCache"},
	 { "delete_SoBoundingBoxCache", _wrap_delete_SoBoundingBoxCache, METH_O, "delete_SoBoundingBoxCache(SoBoundingBoxCache self)"},
	 { "SoBoundingBoxCache_set", _wrap_SoBoundingBoxCache_set, METH_VARARGS, "SoBoundingBoxCache_set(SoBoundingBoxCache self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"},
	 { "SoBoundingBoxCache_getBox", _wrap_SoBoundingBoxCache_getBox, METH_O, "SoBoundingBoxCache_getBox(SoBoundingBoxCache self) -> SbXfBox3f"},
	 { "SoBoundingBoxCache_getProjectedBox", _wrap_SoBoundingBoxCache_getProjectedBox, METH_O, "SoBoundingBoxCache_getProjectedBox(SoBoundingBoxCache self) -> SbBox3f"},
	 { "SoBoundingBoxCache_isCenterSet", _wrap_SoBoundingBoxCache_isCenterSet, METH_O, "SoBoundingBoxCache_isCenterSet(SoBoundingBoxCache self) -> SbBool"},
	 { "SoBoundingBoxCache_getCenter", _wrap_SoBoundingBoxCache_getCenter, METH_O, "SoBoundingBoxCache_getCenter(SoBoundingBoxCache self) -> SbVec3f"},
	 { "SoBoundingBoxCache_setHasLinesOrPoints", _wrap_SoBoundingBoxCache_setHasLinesOrPoints, METH_O, "SoBoundingBoxCache_setHasLinesOrPoints(SoState state)"},
	 { "SoBoundingBoxCache_hasLinesOrPoints", _wrap_SoBoundingBoxCache_hasLinesOrPoints, METH_O, "SoBoundingBoxCache_hasLinesOrPoints(SoBoundingBoxCache self) -> SbBool"},
	 { "SoBoundingBoxCache_swigregister", SoBoundingBoxCache_swigregister, METH_O, NULL},
	 { "SoBoundingBoxCache_swiginit", SoBoundingBoxCache_swiginit, METH_VARARGS, NULL},
	 { "new_SoConvexDataCache", _wrap_new_SoConvexDataCache, METH_O, "new_SoConvexDataCache(SoState state) -> SoConvexDataCache"},
	 { "delete_SoConvexDataCache", _wrap_delete_SoConvexDataCache, METH_O, "delete_SoConvexDataCache(SoConvexDataCache self)"},
	 { "SoConvexDataCache_generate", _wrap_SoConvexDataCache_generate, METH_VARARGS, "SoConvexDataCache_generate(SoConvexDataCache self, SoCoordinateElement coords, int32_t const * coordindices, int const numcoordindices, int32_t const * matindices, int32_t const * normindices, int32_t const * texindices, SoConvexDataCache::Binding const matbinding, SoConvexDataCache::Binding const normbinding, SoConvexDataCache::Binding const texbinding)"},
	 { "SoConvexDataCache_getCoordIndices", _wrap_SoConvexDataCache_getCoordIndices, METH_O, "SoConvexDataCache_getCoordIndices(SoConvexDataCache self) -> int32_t const *"},
	 { "SoConvexDataCache_getNumCoordIndices", _wrap_SoConvexDataCache_getNumCoordIndices, METH_O, "SoConvexDataCache_getNumCoordIndices(SoConvexDataCache self) -> int"},
	 { "SoConvexDataCache_getMaterialIndices", _wrap_SoConvexDataCache_getMaterialIndices, METH_O, "SoConvexDataCache_getMaterialIndices(SoConvexDataCache self) -> int32_t const *"},
	 { "SoConvexDataCache_getNumMaterialIndices", _wrap_SoConvexDataCache_getNumMaterialIndices, METH_O, "SoConvexDataCache_getNumMaterialIndices(SoConvexDataCache self) -> int"},
	 { "SoConvexDataCache_getNormalIndices", _wrap_SoConvexDataCache_getNormalIndices, METH_O, "SoConvexDataCache_getNormalIndices(SoConvexDataCache self) -> int32_t const *"},
	 { "SoConvexDataCache_getNumNormalIndices", _wrap_SoConvexDataCache_getNumNormalIndices, METH_O, "SoConvexDataCache_getNumNormalIndices(SoConvexDataCache self) -> int"},
	 { "SoConvexDataCache_getTexIndices", _wrap_SoConvexDataCache_getTexIndices, METH_O, "SoConvexDataCache_getTexIndices(SoConvexDataCache self) -> int32_t const *"},
	 { "SoConvexDataCache_getNumTexIndices", _wrap_SoConvexDataCache_getNumTexIndices, METH_O, "SoConvexDataCache_getNumTexIndices(SoConvexDataCache self) -> int"},
	 { "SoConvexDataCache_swigregister", SoConvexDataCache_swigregister, METH_O, NULL},
	 { "SoConvexDataCache_swiginit", SoConvexDataCache_swiginit, METH_VARARGS, NULL},
	 { "SoGLCacheList_swigregister", SoGLCacheList_swigregister, METH_O, NULL},
	 { "SoGLLazyElement_getClassTypeId", _wrap_SoGLLazyElement_getClassTypeId, METH_NOARGS, "SoGLLazyElement_getClassTypeId() -> SoType"},
	 { "SoGLLazyElement_getClassStackIndex", _wrap_SoGLLazyElement_getClassStackIndex, METH_NOARGS, "SoGLLazyElement_getClassStackIndex() -> int"},
	 { "SoGLLazyElement_createInstance", _wrap_SoGLLazyElement_createInstance, METH_NOARGS, "SoGLLazyElement_createInstance() -> void *"},
	 { "SoGLLazyElement_initClass", _wrap_SoGLLazyElement_initClass, METH_NOARGS, "SoGLLazyElement_initClass()"},
	 { "SoGLLazyElement_init", _wrap_SoGLLazyElement_init, METH_VARARGS, "SoGLLazyElement_init(SoGLLazyElement self, SoState state)"},
	 { "SoGLLazyElement_push", _wrap_SoGLLazyElement_push, METH_VARARGS, "SoGLLazyElement_push(SoGLLazyElement self, SoState state)"},
	 { "SoGLLazyElement_pop", _wrap_SoGLLazyElement_pop, METH_VARARGS, "SoGLLazyElement_pop(SoGLLazyElement self, SoState state, SoElement prevtopelement)"},
	 { "SoGLLazyElement_sendAllMaterial", _wrap_SoGLLazyElement_sendAllMaterial, METH_O, "SoGLLazyElement_sendAllMaterial(SoState state)"},
	 { "SoGLLazyElement_sendNoMaterial", _wrap_SoGLLazyElement_sendNoMaterial, METH_O, "SoGLLazyElement_sendNoMaterial(SoState state)"},
	 { "SoGLLazyElement_sendOnlyDiffuseColor", _wrap_SoGLLazyElement_sendOnlyDiffuseColor, METH_O, "SoGLLazyElement_sendOnlyDiffuseColor(SoState state)"},
	 { "SoGLLazyElement_sendLightModel", _wrap_SoGLLazyElement_sendLightModel, METH_VARARGS, "SoGLLazyElement_sendLightModel(SoState state, int32_t const model)"},
	 { "SoGLLazyElement_sendPackedDiffuse", _wrap_SoGLLazyElement_sendPackedDiffuse, METH_VARARGS, "SoGLLazyElement_sendPackedDiffuse(SoState state, uint32_t const diffuse)"},
	 { "SoGLLazyElement_sendFlatshading", _wrap_SoGLLazyElement_sendFlatshading, METH_VARARGS, "SoGLLazyElement_sendFlatshading(SoState state, SbBool const onoff)"},
	 { "SoGLLazyElement_sendVertexOrdering", _wrap_SoGLLazyElement_sendVertexOrdering, METH_VARARGS, "SoGLLazyElement_sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"},
	 { "SoGLLazyElement_sendTwosideLighting", _wrap_SoGLLazyElement_sendTwosideLighting, METH_VARARGS, "SoGLLazyElement_sendTwosideLighting(SoState state, SbBool const onoff)"},
	 { "SoGLLazyElement_sendBackfaceCulling", _wrap_SoGLLazyElement_sendBackfaceCulling, METH_VARARGS, "SoGLLazyElement_sendBackfaceCulling(SoState state, SbBool const onoff)"},
	 { "SoGLLazyElement_sendDiffuseByIndex", _wrap_SoGLLazyElement_sendDiffuseByIndex, METH_VARARGS, "SoGLLazyElement_sendDiffuseByIndex(SoGLLazyElement self, int const index)"},
	 { "SoGLLazyElement_isColorIndex", _wrap_SoGLLazyElement_isColorIndex, METH_O, "SoGLLazyElement_isColorIndex(SoState state) -> SbBool"},
	 { "SoGLLazyElement_getInstance", _wrap_SoGLLazyElement_getInstance, METH_O, "SoGLLazyElement_getInstance(SoState state) -> SoGLLazyElement"},
	 { "SoGLLazyElement_send", _wrap_SoGLLazyElement_send, METH_VARARGS, "SoGLLazyElement_send(SoGLLazyElement self, SoState state, uint32_t mask)"},
	 { "SoGLLazyElement_sendVPPacked", _wrap_SoGLLazyElement_sendVPPacked, METH_VARARGS, "SoGLLazyElement_sendVPPacked(SoGLLazyElement self, SoState state, unsigned char const * pcolor)"},
	 { "SoGLLazyElement_reset", _wrap_SoGLLazyElement_reset, METH_VARARGS, "SoGLLazyElement_reset(SoGLLazyElement self, SoState state, uint32_t bitmask)"},
	 { "SoGLLazyElement_setDiffuseElt", _wrap_SoGLLazyElement_setDiffuseElt, METH_VARARGS, "SoGLLazyElement_setDiffuseElt(SoGLLazyElement self, SoNode arg2, int32_t numcolors, SbColor colors, SoColorPacker packer)"},
	 { "SoGLLazyElement_setPackedElt", _wrap_SoGLLazyElement_setPackedElt, METH_VARARGS, "SoGLLazyElement_setPackedElt(SoGLLazyElement self, SoNode node, int32_t numcolors, uint32_t const * colors, SbBool const packedtransparency)"},
	 { "SoGLLazyElement_setColorIndexElt", _wrap_SoGLLazyElement_setColorIndexElt, METH_VARARGS, "SoGLLazyElement_setColorIndexElt(SoGLLazyElement self, SoNode node, int32_t numindices, int32_t const * indices)"},
	 { "SoGLLazyElement_setTranspElt", _wrap_SoGLLazyElement_setTranspElt, METH_VARARGS, "SoGLLazyElement_setTranspElt(SoGLLazyElement self, SoNode node, int32_t numtransp, float const * transp, SoColorPacker packer)"},
	 { "SoGLLazyElement_setTranspTypeElt", _wrap_SoGLLazyElement_setTranspTypeElt, METH_VARARGS, "SoGLLazyElement_setTranspTypeElt(SoGLLazyElement self, int32_t type)"},
	 { "SoGLLazyElement_setAmbientElt", _wrap_SoGLLazyElement_setAmbientElt, METH_VARARGS, "SoGLLazyElement_setAmbientElt(SoGLLazyElement self, SbColor color)"},
	 { "SoGLLazyElement_setEmissiveElt", _wrap_SoGLLazyElement_setEmissiveElt, METH_VARARGS, "SoGLLazyElement_setEmissiveElt(SoGLLazyElement self, SbColor color)"},
	 { "SoGLLazyElement_setSpecularElt", _wrap_SoGLLazyElement_setSpecularElt, METH_VARARGS, "SoGLLazyElement_setSpecularElt(SoGLLazyElement self, SbColor color)"},
	 { "SoGLLazyElement_setShininessElt", _wrap_SoGLLazyElement_setShininessElt, METH_VARARGS, "SoGLLazyElement_setShininessElt(SoGLLazyElement self, float value)"},
	 { "SoGLLazyElement_setColorMaterialElt", _wrap_SoGLLazyElement_setColorMaterialElt, METH_VARARGS, "SoGLLazyElement_setColorMaterialElt(SoGLLazyElement self, SbBool value)"},
	 { "SoGLLazyElement_enableBlendingElt", _wrap_SoGLLazyElement_enableBlendingElt, METH_VARARGS, "SoGLLazyElement_enableBlendingElt(SoGLLazyElement self, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"},
	 { "SoGLLazyElement_disableBlendingElt", _wrap_SoGLLazyElement_disableBlendingElt, METH_O, "SoGLLazyElement_disableBlendingElt(SoGLLazyElement self)"},
	 { "SoGLLazyElement_setLightModelElt", _wrap_SoGLLazyElement_setLightModelElt, METH_VARARGS, "SoGLLazyElement_setLightModelElt(SoGLLazyElement self, SoState state, int32_t model)"},
	 { "SoGLLazyElement_setMaterialElt", _wrap_SoGLLazyElement_setMaterialElt, METH_VARARGS, "SoGLLazyElement_setMaterialElt(SoGLLazyElement self, SoNode node, uint32_t bitmask, SoColorPacker packer, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"},
	 { "SoGLLazyElement_setVertexOrderingElt", _wrap_SoGLLazyElement_setVertexOrderingElt, METH_VARARGS, "SoGLLazyElement_setVertexOrderingElt(SoGLLazyElement self, SoLazyElement::VertexOrdering ordering)"},
	 { "SoGLLazyElement_setBackfaceCullingElt", _wrap_SoGLLazyElement_setBackfaceCullingElt, METH_VARARGS, "SoGLLazyElement_setBackfaceCullingElt(SoGLLazyElement self, SbBool onoff)"},
	 { "SoGLLazyElement_setTwosideLightingElt", _wrap_SoGLLazyElement_setTwosideLightingElt, METH_VARARGS, "SoGLLazyElement_setTwosideLightingElt(SoGLLazyElement self, SbBool onoff)"},
	 { "SoGLLazyElement_setShadeModelElt", _wrap_SoGLLazyElement_setShadeModelElt, METH_VARARGS, "SoGLLazyElement_setShadeModelElt(SoGLLazyElement self, SbBool flatshading)"},
	 { "SoGLLazyElement_setAlphaTestElt", _wrap_SoGLLazyElement_setAlphaTestElt, METH_VARARGS, "SoGLLazyElement_setAlphaTestElt(SoGLLazyElement self, int func, float value)"},
	 { "SoGLLazyElement_beginCaching", _wrap_SoGLLazyElement_beginCaching, METH_VARARGS, "SoGLLazyElement_beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"},
	 { "SoGLLazyElement_endCaching", _wrap_SoGLLazyElement_endCaching, METH_O, "SoGLLazyElement_endCaching(SoState state)"},
	 { "SoGLLazyElement_preCacheCall", _wrap_SoGLLazyElement_preCacheCall, METH_VARARGS, "SoGLLazyElement_preCacheCall(SoState state, SoGLLazyElement::GLState const * prestate) -> SbBool"},
	 { "SoGLLazyElement_postCacheCall", _wrap_SoGLLazyElement_postCacheCall, METH_VARARGS, "SoGLLazyElement_postCacheCall(SoState state, SoGLLazyElement::GLState const * poststate)"},
	 { "SoGLLazyElement_mergeCacheInfo", _wrap_SoGLLazyElement_mergeCacheInfo, METH_VARARGS, "SoGLLazyElement_mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"},
	 { "SoGLLazyElement_updateColorVBO", _wrap_SoGLLazyElement_updateColorVBO, METH_VARARGS, "SoGLLazyElement_updateColorVBO(SoGLLazyElement self, SoVBO * vbo)"},
	 { "SoGLLazyElement_swigregister", SoGLLazyElement_swigregister, METH_O, NULL},
	 { "delete_SoGLRenderCache", _wrap_delete_SoGLRenderCache, METH_O, "delete_SoGLRenderCache(SoGLRenderCache self)"},
	 { "SoGLRenderCache_isValid", _wrap_SoGLRenderCache_isValid, METH_VARARGS, "SoGLRenderCache_isValid(SoGLRenderCache self, SoState state) -> SbBool"},
	 { "SoGLRenderCache_addNestedCache", _wrap_SoGLRenderCache_addNestedCache, METH_VARARGS, "SoGLRenderCache_addNestedCache(SoGLRenderCache self, SoGLDisplayList child)"},
	 { "SoGLRenderCache_swigregister", SoGLRenderCache_swigregister, METH_O, NULL},
	 { "new_SoNormalCache", _wrap_new_SoNormalCache, METH_O, "new_SoNormalCache(SoState state) -> SoNormalCache"},
	 { "delete_SoNormalCache", _wrap_delete_SoNormalCache, METH_O, "delete_SoNormalCache(SoNormalCache self)"},
	 { "SoNormalCache_set", _wrap_SoNormalCache_set, METH_VARARGS, "\n"
		"SoNormalCache_set(SoNormalCache self, int const num, SbVec3f normals)\n"
		"SoNormalCache_set(SoNormalCache self, SoNormalGenerator generator)\n"
		""},
	 { "SoNormalCache_getNum", _wrap_SoNormalCache_getNum, METH_O, "SoNormalCache_getNum(SoNormalCache self) -> int"},
	 { "SoNormalCache_getNormals", _wrap_SoNormalCache_getNormals, METH_O, "SoNormalCache_getNormals(SoNormalCache self) -> SbVec3f"},
	 { "SoNormalCache_getNumIndices", _wrap_SoNormalCache_getNumIndices, METH_O, "SoNormalCache_getNumIndices(SoNormalCache self) -> int"},
	 { "SoNormalCache_getIndices", _wrap_SoNormalCache_getIndices, METH_O, "SoNormalCache_getIndices(SoNormalCache self) -> int32_t const *"},
	 { "SoNormalCache_generatePerVertex", _wrap_SoNormalCache_generatePerVertex, METH_VARARGS, "SoNormalCache_generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1, SbBool const tristrip=0)"},
	 { "SoNormalCache_generatePerFace", _wrap_SoNormalCache_generatePerFace, METH_VARARGS, "SoNormalCache_generatePerFace(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"},
	 { "SoNormalCache_generatePerFaceStrip", _wrap_SoNormalCache_generatePerFaceStrip, METH_VARARGS, "SoNormalCache_generatePerFaceStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"},
	 { "SoNormalCache_generatePerStrip", _wrap_SoNormalCache_generatePerStrip, METH_VARARGS, "SoNormalCache_generatePerStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"},
	 { "SoNormalCache_generatePerVertexQuad", _wrap_SoNormalCache_generatePerVertexQuad, METH_VARARGS, "SoNormalCache_generatePerVertexQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"},
	 { "SoNormalCache_generatePerFaceQuad", _wrap_SoNormalCache_generatePerFaceQuad, METH_VARARGS, "SoNormalCache_generatePerFaceQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"},
	 { "SoNormalCache_generatePerRowQuad", _wrap_SoNormalCache_generatePerRowQuad, METH_VARARGS, "SoNormalCache_generatePerRowQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"},
	 { "SoNormalCache_swigregister", SoNormalCache_swigregister, METH_O, NULL},
	 { "SoNormalCache_swiginit", SoNormalCache_swiginit, METH_VARARGS, NULL},
	 { "new_SoTextureCoordinateCache", _wrap_new_SoTextureCoordinateCache, METH_O, "new_SoTextureCoordinateCache(SoState state) -> SoTextureCoordinateCache"},
	 { "delete_SoTextureCoordinateCache", _wrap_delete_SoTextureCoordinateCache, METH_O, "delete_SoTextureCoordinateCache(SoTextureCoordinateCache self)"},
	 { "SoTextureCoordinateCache_generate", _wrap_SoTextureCoordinateCache_generate, METH_VARARGS, "SoTextureCoordinateCache_generate(SoTextureCoordinateCache self, SbBox3f bbox, SbVec3f vertices, int const numvertices)"},
	 { "SoTextureCoordinateCache_get", _wrap_SoTextureCoordinateCache_get, METH_O, "SoTextureCoordinateCache_get(SoTextureCoordinateCache self) -> SbVec2f"},
	 { "SoTextureCoordinateCache_getNum", _wrap_SoTextureCoordinateCache_getNum, METH_O, "SoTextureCoordinateCache_getNum(SoTextureCoordinateCache self) -> int"},
	 { "SoTextureCoordinateCache_swigregister", SoTextureCoordinateCache_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateCache_swiginit", SoTextureCoordinateCache_swiginit, METH_VARARGS, NULL},
	 { "delete_SoDetail", _wrap_delete_SoDetail, METH_O, "delete_SoDetail(SoDetail self)"},
	 { "SoDetail_initClass", _wrap_SoDetail_initClass, METH_NOARGS, "SoDetail_initClass()"},
	 { "SoDetail_initClasses", _wrap_SoDetail_initClasses, METH_NOARGS, "SoDetail_initClasses()"},
	 { "SoDetail_copy", _wrap_SoDetail_copy, METH_O, "SoDetail_copy(SoDetail self) -> SoDetail"},
	 { "SoDetail_getTypeId", _wrap_SoDetail_getTypeId, METH_O, "SoDetail_getTypeId(SoDetail self) -> SoType"},
	 { "SoDetail_isOfType", _wrap_SoDetail_isOfType, METH_VARARGS, "SoDetail_isOfType(SoDetail self, SoType type) -> SbBool"},
	 { "SoDetail_getClassTypeId", _wrap_SoDetail_getClassTypeId, METH_NOARGS, "SoDetail_getClassTypeId() -> SoType"},
	 { "SoDetail_swigregister", SoDetail_swigregister, METH_O, NULL},
	 { "SoConeDetail_getTypeId", _wrap_SoConeDetail_getTypeId, METH_O, "SoConeDetail_getTypeId(SoConeDetail self) -> SoType"},
	 { "SoConeDetail_getClassTypeId", _wrap_SoConeDetail_getClassTypeId, METH_NOARGS, "SoConeDetail_getClassTypeId() -> SoType"},
	 { "SoConeDetail_cleanupClass", _wrap_SoConeDetail_cleanupClass, METH_NOARGS, "SoConeDetail_cleanupClass()"},
	 { "new_SoConeDetail", _wrap_new_SoConeDetail, METH_NOARGS, "new_SoConeDetail() -> SoConeDetail"},
	 { "delete_SoConeDetail", _wrap_delete_SoConeDetail, METH_O, "delete_SoConeDetail(SoConeDetail self)"},
	 { "SoConeDetail_initClass", _wrap_SoConeDetail_initClass, METH_NOARGS, "SoConeDetail_initClass()"},
	 { "SoConeDetail_copy", _wrap_SoConeDetail_copy, METH_O, "SoConeDetail_copy(SoConeDetail self) -> SoDetail"},
	 { "SoConeDetail_setPart", _wrap_SoConeDetail_setPart, METH_VARARGS, "SoConeDetail_setPart(SoConeDetail self, int const part)"},
	 { "SoConeDetail_getPart", _wrap_SoConeDetail_getPart, METH_O, "SoConeDetail_getPart(SoConeDetail self) -> int"},
	 { "SoConeDetail_swigregister", SoConeDetail_swigregister, METH_O, NULL},
	 { "SoConeDetail_swiginit", SoConeDetail_swiginit, METH_VARARGS, NULL},
	 { "SoCubeDetail_getTypeId", _wrap_SoCubeDetail_getTypeId, METH_O, "SoCubeDetail_getTypeId(SoCubeDetail self) -> SoType"},
	 { "SoCubeDetail_getClassTypeId", _wrap_SoCubeDetail_getClassTypeId, METH_NOARGS, "SoCubeDetail_getClassTypeId() -> SoType"},
	 { "SoCubeDetail_cleanupClass", _wrap_SoCubeDetail_cleanupClass, METH_NOARGS, "SoCubeDetail_cleanupClass()"},
	 { "new_SoCubeDetail", _wrap_new_SoCubeDetail, METH_NOARGS, "new_SoCubeDetail() -> SoCubeDetail"},
	 { "delete_SoCubeDetail", _wrap_delete_SoCubeDetail, METH_O, "delete_SoCubeDetail(SoCubeDetail self)"},
	 { "SoCubeDetail_initClass", _wrap_SoCubeDetail_initClass, METH_NOARGS, "SoCubeDetail_initClass()"},
	 { "SoCubeDetail_copy", _wrap_SoCubeDetail_copy, METH_O, "SoCubeDetail_copy(SoCubeDetail self) -> SoDetail"},
	 { "SoCubeDetail_setPart", _wrap_SoCubeDetail_setPart, METH_VARARGS, "SoCubeDetail_setPart(SoCubeDetail self, int const part)"},
	 { "SoCubeDetail_getPart", _wrap_SoCubeDetail_getPart, METH_O, "SoCubeDetail_getPart(SoCubeDetail self) -> int"},
	 { "SoCubeDetail_swigregister", SoCubeDetail_swigregister, METH_O, NULL},
	 { "SoCubeDetail_swiginit", SoCubeDetail_swiginit, METH_VARARGS, NULL},
	 { "SoCylinderDetail_getTypeId", _wrap_SoCylinderDetail_getTypeId, METH_O, "SoCylinderDetail_getTypeId(SoCylinderDetail self) -> SoType"},
	 { "SoCylinderDetail_getClassTypeId", _wrap_SoCylinderDetail_getClassTypeId, METH_NOARGS, "SoCylinderDetail_getClassTypeId() -> SoType"},
	 { "SoCylinderDetail_cleanupClass", _wrap_SoCylinderDetail_cleanupClass, METH_NOARGS, "SoCylinderDetail_cleanupClass()"},
	 { "new_SoCylinderDetail", _wrap_new_SoCylinderDetail, METH_NOARGS, "new_SoCylinderDetail() -> SoCylinderDetail"},
	 { "delete_SoCylinderDetail", _wrap_delete_SoCylinderDetail, METH_O, "delete_SoCylinderDetail(SoCylinderDetail self)"},
	 { "SoCylinderDetail_initClass", _wrap_SoCylinderDetail_initClass, METH_NOARGS, "SoCylinderDetail_initClass()"},
	 { "SoCylinderDetail_copy", _wrap_SoCylinderDetail_copy, METH_O, "SoCylinderDetail_copy(SoCylinderDetail self) -> SoDetail"},
	 { "SoCylinderDetail_setPart", _wrap_SoCylinderDetail_setPart, METH_VARARGS, "SoCylinderDetail_setPart(SoCylinderDetail self, int const part)"},
	 { "SoCylinderDetail_getPart", _wrap_SoCylinderDetail_getPart, METH_O, "SoCylinderDetail_getPart(SoCylinderDetail self) -> int"},
	 { "SoCylinderDetail_swigregister", SoCylinderDetail_swigregister, METH_O, NULL},
	 { "SoCylinderDetail_swiginit", SoCylinderDetail_swiginit, METH_VARARGS, NULL},
	 { "SoPointDetail_getTypeId", _wrap_SoPointDetail_getTypeId, METH_O, "SoPointDetail_getTypeId(SoPointDetail self) -> SoType"},
	 { "SoPointDetail_getClassTypeId", _wrap_SoPointDetail_getClassTypeId, METH_NOARGS, "SoPointDetail_getClassTypeId() -> SoType"},
	 { "SoPointDetail_cleanupClass", _wrap_SoPointDetail_cleanupClass, METH_NOARGS, "SoPointDetail_cleanupClass()"},
	 { "new_SoPointDetail", _wrap_new_SoPointDetail, METH_NOARGS, "new_SoPointDetail() -> SoPointDetail"},
	 { "delete_SoPointDetail", _wrap_delete_SoPointDetail, METH_O, "delete_SoPointDetail(SoPointDetail self)"},
	 { "SoPointDetail_initClass", _wrap_SoPointDetail_initClass, METH_NOARGS, "SoPointDetail_initClass()"},
	 { "SoPointDetail_copy", _wrap_SoPointDetail_copy, METH_O, "SoPointDetail_copy(SoPointDetail self) -> SoDetail"},
	 { "SoPointDetail_getCoordinateIndex", _wrap_SoPointDetail_getCoordinateIndex, METH_O, "SoPointDetail_getCoordinateIndex(SoPointDetail self) -> int"},
	 { "SoPointDetail_getMaterialIndex", _wrap_SoPointDetail_getMaterialIndex, METH_O, "SoPointDetail_getMaterialIndex(SoPointDetail self) -> int"},
	 { "SoPointDetail_getNormalIndex", _wrap_SoPointDetail_getNormalIndex, METH_O, "SoPointDetail_getNormalIndex(SoPointDetail self) -> int"},
	 { "SoPointDetail_getTextureCoordIndex", _wrap_SoPointDetail_getTextureCoordIndex, METH_O, "SoPointDetail_getTextureCoordIndex(SoPointDetail self) -> int"},
	 { "SoPointDetail_setCoordinateIndex", _wrap_SoPointDetail_setCoordinateIndex, METH_VARARGS, "SoPointDetail_setCoordinateIndex(SoPointDetail self, int const idx)"},
	 { "SoPointDetail_setMaterialIndex", _wrap_SoPointDetail_setMaterialIndex, METH_VARARGS, "SoPointDetail_setMaterialIndex(SoPointDetail self, int const idx)"},
	 { "SoPointDetail_setNormalIndex", _wrap_SoPointDetail_setNormalIndex, METH_VARARGS, "SoPointDetail_setNormalIndex(SoPointDetail self, int const idx)"},
	 { "SoPointDetail_setTextureCoordIndex", _wrap_SoPointDetail_setTextureCoordIndex, METH_VARARGS, "SoPointDetail_setTextureCoordIndex(SoPointDetail self, int const idx)"},
	 { "SoPointDetail_swigregister", SoPointDetail_swigregister, METH_O, NULL},
	 { "SoPointDetail_swiginit", SoPointDetail_swiginit, METH_VARARGS, NULL},
	 { "SoFaceDetail_getTypeId", _wrap_SoFaceDetail_getTypeId, METH_O, "SoFaceDetail_getTypeId(SoFaceDetail self) -> SoType"},
	 { "SoFaceDetail_getClassTypeId", _wrap_SoFaceDetail_getClassTypeId, METH_NOARGS, "SoFaceDetail_getClassTypeId() -> SoType"},
	 { "SoFaceDetail_cleanupClass", _wrap_SoFaceDetail_cleanupClass, METH_NOARGS, "SoFaceDetail_cleanupClass()"},
	 { "new_SoFaceDetail", _wrap_new_SoFaceDetail, METH_NOARGS, "new_SoFaceDetail() -> SoFaceDetail"},
	 { "delete_SoFaceDetail", _wrap_delete_SoFaceDetail, METH_O, "delete_SoFaceDetail(SoFaceDetail self)"},
	 { "SoFaceDetail_initClass", _wrap_SoFaceDetail_initClass, METH_NOARGS, "SoFaceDetail_initClass()"},
	 { "SoFaceDetail_copy", _wrap_SoFaceDetail_copy, METH_O, "SoFaceDetail_copy(SoFaceDetail self) -> SoDetail"},
	 { "SoFaceDetail_getNumPoints", _wrap_SoFaceDetail_getNumPoints, METH_O, "SoFaceDetail_getNumPoints(SoFaceDetail self) -> int"},
	 { "SoFaceDetail_getPoint", _wrap_SoFaceDetail_getPoint, METH_VARARGS, "SoFaceDetail_getPoint(SoFaceDetail self, int const idx) -> SoPointDetail"},
	 { "SoFaceDetail_getPoints", _wrap_SoFaceDetail_getPoints, METH_O, "SoFaceDetail_getPoints(SoFaceDetail self) -> SoPointDetail"},
	 { "SoFaceDetail_getFaceIndex", _wrap_SoFaceDetail_getFaceIndex, METH_O, "SoFaceDetail_getFaceIndex(SoFaceDetail self) -> int"},
	 { "SoFaceDetail_getPartIndex", _wrap_SoFaceDetail_getPartIndex, METH_O, "SoFaceDetail_getPartIndex(SoFaceDetail self) -> int"},
	 { "SoFaceDetail_setNumPoints", _wrap_SoFaceDetail_setNumPoints, METH_VARARGS, "SoFaceDetail_setNumPoints(SoFaceDetail self, int const num)"},
	 { "SoFaceDetail_setPoint", _wrap_SoFaceDetail_setPoint, METH_VARARGS, "SoFaceDetail_setPoint(SoFaceDetail self, int const idx, SoPointDetail detail)"},
	 { "SoFaceDetail_setFaceIndex", _wrap_SoFaceDetail_setFaceIndex, METH_VARARGS, "SoFaceDetail_setFaceIndex(SoFaceDetail self, int const idx)"},
	 { "SoFaceDetail_setPartIndex", _wrap_SoFaceDetail_setPartIndex, METH_VARARGS, "SoFaceDetail_setPartIndex(SoFaceDetail self, int const idx)"},
	 { "SoFaceDetail_incFaceIndex", _wrap_SoFaceDetail_incFaceIndex, METH_O, "SoFaceDetail_incFaceIndex(SoFaceDetail self)"},
	 { "SoFaceDetail_incPartIndex", _wrap_SoFaceDetail_incPartIndex, METH_O, "SoFaceDetail_incPartIndex(SoFaceDetail self)"},
	 { "SoFaceDetail_swigregister", SoFaceDetail_swigregister, METH_O, NULL},
	 { "SoFaceDetail_swiginit", SoFaceDetail_swiginit, METH_VARARGS, NULL},
	 { "SoLineDetail_getTypeId", _wrap_SoLineDetail_getTypeId, METH_O, "SoLineDetail_getTypeId(SoLineDetail self) -> SoType"},
	 { "SoLineDetail_getClassTypeId", _wrap_SoLineDetail_getClassTypeId, METH_NOARGS, "SoLineDetail_getClassTypeId() -> SoType"},
	 { "SoLineDetail_cleanupClass", _wrap_SoLineDetail_cleanupClass, METH_NOARGS, "SoLineDetail_cleanupClass()"},
	 { "new_SoLineDetail", _wrap_new_SoLineDetail, METH_NOARGS, "new_SoLineDetail() -> SoLineDetail"},
	 { "delete_SoLineDetail", _wrap_delete_SoLineDetail, METH_O, "delete_SoLineDetail(SoLineDetail self)"},
	 { "SoLineDetail_initClass", _wrap_SoLineDetail_initClass, METH_NOARGS, "SoLineDetail_initClass()"},
	 { "SoLineDetail_copy", _wrap_SoLineDetail_copy, METH_O, "SoLineDetail_copy(SoLineDetail self) -> SoDetail"},
	 { "SoLineDetail_getPoint0", _wrap_SoLineDetail_getPoint0, METH_O, "SoLineDetail_getPoint0(SoLineDetail self) -> SoPointDetail"},
	 { "SoLineDetail_getPoint1", _wrap_SoLineDetail_getPoint1, METH_O, "SoLineDetail_getPoint1(SoLineDetail self) -> SoPointDetail"},
	 { "SoLineDetail_getLineIndex", _wrap_SoLineDetail_getLineIndex, METH_O, "SoLineDetail_getLineIndex(SoLineDetail self) -> int"},
	 { "SoLineDetail_getPartIndex", _wrap_SoLineDetail_getPartIndex, METH_O, "SoLineDetail_getPartIndex(SoLineDetail self) -> int"},
	 { "SoLineDetail_setPoint0", _wrap_SoLineDetail_setPoint0, METH_VARARGS, "SoLineDetail_setPoint0(SoLineDetail self, SoPointDetail detail)"},
	 { "SoLineDetail_setPoint1", _wrap_SoLineDetail_setPoint1, METH_VARARGS, "SoLineDetail_setPoint1(SoLineDetail self, SoPointDetail detail)"},
	 { "SoLineDetail_setLineIndex", _wrap_SoLineDetail_setLineIndex, METH_VARARGS, "SoLineDetail_setLineIndex(SoLineDetail self, int const idx)"},
	 { "SoLineDetail_setPartIndex", _wrap_SoLineDetail_setPartIndex, METH_VARARGS, "SoLineDetail_setPartIndex(SoLineDetail self, int const idx)"},
	 { "SoLineDetail_incLineIndex", _wrap_SoLineDetail_incLineIndex, METH_O, "SoLineDetail_incLineIndex(SoLineDetail self)"},
	 { "SoLineDetail_incPartIndex", _wrap_SoLineDetail_incPartIndex, METH_O, "SoLineDetail_incPartIndex(SoLineDetail self)"},
	 { "SoLineDetail_swigregister", SoLineDetail_swigregister, METH_O, NULL},
	 { "SoLineDetail_swiginit", SoLineDetail_swiginit, METH_VARARGS, NULL},
	 { "SoNodeKitDetail_getTypeId", _wrap_SoNodeKitDetail_getTypeId, METH_O, "SoNodeKitDetail_getTypeId(SoNodeKitDetail self) -> SoType"},
	 { "SoNodeKitDetail_getClassTypeId", _wrap_SoNodeKitDetail_getClassTypeId, METH_NOARGS, "SoNodeKitDetail_getClassTypeId() -> SoType"},
	 { "SoNodeKitDetail_cleanupClass", _wrap_SoNodeKitDetail_cleanupClass, METH_NOARGS, "SoNodeKitDetail_cleanupClass()"},
	 { "new_SoNodeKitDetail", _wrap_new_SoNodeKitDetail, METH_NOARGS, "new_SoNodeKitDetail() -> SoNodeKitDetail"},
	 { "delete_SoNodeKitDetail", _wrap_delete_SoNodeKitDetail, METH_O, "delete_SoNodeKitDetail(SoNodeKitDetail self)"},
	 { "SoNodeKitDetail_initClass", _wrap_SoNodeKitDetail_initClass, METH_NOARGS, "SoNodeKitDetail_initClass()"},
	 { "SoNodeKitDetail_copy", _wrap_SoNodeKitDetail_copy, METH_O, "SoNodeKitDetail_copy(SoNodeKitDetail self) -> SoDetail"},
	 { "SoNodeKitDetail_setNodeKit", _wrap_SoNodeKitDetail_setNodeKit, METH_VARARGS, "SoNodeKitDetail_setNodeKit(SoNodeKitDetail self, SoBaseKit kit)"},
	 { "SoNodeKitDetail_getNodeKit", _wrap_SoNodeKitDetail_getNodeKit, METH_O, "SoNodeKitDetail_getNodeKit(SoNodeKitDetail self) -> SoBaseKit"},
	 { "SoNodeKitDetail_setPart", _wrap_SoNodeKitDetail_setPart, METH_VARARGS, "SoNodeKitDetail_setPart(SoNodeKitDetail self, SoNode part)"},
	 { "SoNodeKitDetail_getPart", _wrap_SoNodeKitDetail_getPart, METH_O, "SoNodeKitDetail_getPart(SoNodeKitDetail self) -> SoNode"},
	 { "SoNodeKitDetail_setPartName", _wrap_SoNodeKitDetail_setPartName, METH_VARARGS, "SoNodeKitDetail_setPartName(SoNodeKitDetail self, SbName name)"},
	 { "SoNodeKitDetail_getPartName", _wrap_SoNodeKitDetail_getPartName, METH_O, "SoNodeKitDetail_getPartName(SoNodeKitDetail self) -> SbName"},
	 { "SoNodeKitDetail_swigregister", SoNodeKitDetail_swigregister, METH_O, NULL},
	 { "SoNodeKitDetail_swiginit", SoNodeKitDetail_swiginit, METH_VARARGS, NULL},
	 { "SoTextDetail_getTypeId", _wrap_SoTextDetail_getTypeId, METH_O, "SoTextDetail_getTypeId(SoTextDetail self) -> SoType"},
	 { "SoTextDetail_getClassTypeId", _wrap_SoTextDetail_getClassTypeId, METH_NOARGS, "SoTextDetail_getClassTypeId() -> SoType"},
	 { "SoTextDetail_cleanupClass", _wrap_SoTextDetail_cleanupClass, METH_NOARGS, "SoTextDetail_cleanupClass()"},
	 { "new_SoTextDetail", _wrap_new_SoTextDetail, METH_NOARGS, "new_SoTextDetail() -> SoTextDetail"},
	 { "delete_SoTextDetail", _wrap_delete_SoTextDetail, METH_O, "delete_SoTextDetail(SoTextDetail self)"},
	 { "SoTextDetail_initClass", _wrap_SoTextDetail_initClass, METH_NOARGS, "SoTextDetail_initClass()"},
	 { "SoTextDetail_copy", _wrap_SoTextDetail_copy, METH_O, "SoTextDetail_copy(SoTextDetail self) -> SoDetail"},
	 { "SoTextDetail_getStringIndex", _wrap_SoTextDetail_getStringIndex, METH_O, "SoTextDetail_getStringIndex(SoTextDetail self) -> int"},
	 { "SoTextDetail_getCharacterIndex", _wrap_SoTextDetail_getCharacterIndex, METH_O, "SoTextDetail_getCharacterIndex(SoTextDetail self) -> int"},
	 { "SoTextDetail_getPart", _wrap_SoTextDetail_getPart, METH_O, "SoTextDetail_getPart(SoTextDetail self) -> int"},
	 { "SoTextDetail_setStringIndex", _wrap_SoTextDetail_setStringIndex, METH_VARARGS, "SoTextDetail_setStringIndex(SoTextDetail self, int const idx)"},
	 { "SoTextDetail_setCharacterIndex", _wrap_SoTextDetail_setCharacterIndex, METH_VARARGS, "SoTextDetail_setCharacterIndex(SoTextDetail self, int const idx)"},
	 { "SoTextDetail_setPart", _wrap_SoTextDetail_setPart, METH_VARARGS, "SoTextDetail_setPart(SoTextDetail self, int const idx)"},
	 { "SoTextDetail_swigregister", SoTextDetail_swigregister, METH_O, NULL},
	 { "SoTextDetail_swiginit", SoTextDetail_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFNode", _wrap_new_SoSFNode, METH_NOARGS, "new_SoSFNode() -> SoSFNode"},
	 { "delete_SoSFNode", _wrap_delete_SoSFNode, METH_O, "delete_SoSFNode(SoSFNode self)"},
	 { "SoSFNode_createInstance", _wrap_SoSFNode_createInstance, METH_NOARGS, "SoSFNode_createInstance() -> void *"},
	 { "SoSFNode_getClassTypeId", _wrap_SoSFNode_getClassTypeId, METH_NOARGS, "SoSFNode_getClassTypeId() -> SoType"},
	 { "SoSFNode_getTypeId", _wrap_SoSFNode_getTypeId, METH_O, "SoSFNode_getTypeId(SoSFNode self) -> SoType"},
	 { "SoSFNode_copyFrom", _wrap_SoSFNode_copyFrom, METH_VARARGS, "SoSFNode_copyFrom(SoSFNode self, SoField field)"},
	 { "SoSFNode_isSame", _wrap_SoSFNode_isSame, METH_VARARGS, "SoSFNode_isSame(SoSFNode self, SoField field) -> SbBool"},
	 { "SoSFNode_getValue", _wrap_SoSFNode_getValue, METH_O, "SoSFNode_getValue(SoSFNode self) -> SoNode"},
	 { "SoSFNode___eq__", _wrap_SoSFNode___eq__, METH_VARARGS, "SoSFNode___eq__(SoSFNode self, SoSFNode field) -> int"},
	 { "SoSFNode___ne__", _wrap_SoSFNode___ne__, METH_VARARGS, "SoSFNode___ne__(SoSFNode self, SoSFNode field) -> int"},
	 { "SoSFNode_initClass", _wrap_SoSFNode_initClass, METH_NOARGS, "SoSFNode_initClass()"},
	 { "SoSFNode_fixCopy", _wrap_SoSFNode_fixCopy, METH_VARARGS, "SoSFNode_fixCopy(SoSFNode self, SbBool copyconnections)"},
	 { "SoSFNode_referencesCopy", _wrap_SoSFNode_referencesCopy, METH_O, "SoSFNode_referencesCopy(SoSFNode self) -> SbBool"},
	 { "SoSFNode_setValue", _wrap_SoSFNode_setValue, METH_VARARGS, "\n"
		"SoSFNode_setValue(SoSFNode self, SoNode newvalue)\n"
		"SoSFNode_setValue(SoSFNode self, SoSFNode other)\n"
		""},
	 { "SoSFNode_swigregister", SoSFNode_swigregister, METH_O, NULL},
	 { "SoSFNode_swiginit", SoSFNode_swiginit, METH_VARARGS, NULL},
	 { "SoNodekitCatalog_initClass", _wrap_SoNodekitCatalog_initClass, METH_NOARGS, "SoNodekitCatalog_initClass()"},
	 { "new_SoNodekitCatalog", _wrap_new_SoNodekitCatalog, METH_NOARGS, "new_SoNodekitCatalog() -> SoNodekitCatalog"},
	 { "delete_SoNodekitCatalog", _wrap_delete_SoNodekitCatalog, METH_O, "delete_SoNodekitCatalog(SoNodekitCatalog self)"},
	 { "SoNodekitCatalog_getNumEntries", _wrap_SoNodekitCatalog_getNumEntries, METH_O, "SoNodekitCatalog_getNumEntries(SoNodekitCatalog self) -> int"},
	 { "SoNodekitCatalog_getPartNumber", _wrap_SoNodekitCatalog_getPartNumber, METH_VARARGS, "SoNodekitCatalog_getPartNumber(SoNodekitCatalog self, SbName name) -> int"},
	 { "SoNodekitCatalog_getName", _wrap_SoNodekitCatalog_getName, METH_VARARGS, "SoNodekitCatalog_getName(SoNodekitCatalog self, int part) -> SbName"},
	 { "SoNodekitCatalog_getType", _wrap_SoNodekitCatalog_getType, METH_VARARGS, "\n"
		"SoNodekitCatalog_getType(SoNodekitCatalog self, int part) -> SoType\n"
		"SoNodekitCatalog_getType(SoNodekitCatalog self, SbName name) -> SoType\n"
		""},
	 { "SoNodekitCatalog_getDefaultType", _wrap_SoNodekitCatalog_getDefaultType, METH_VARARGS, "\n"
		"SoNodekitCatalog_getDefaultType(SoNodekitCatalog self, int part) -> SoType\n"
		"SoNodekitCatalog_getDefaultType(SoNodekitCatalog self, SbName name) -> SoType\n"
		""},
	 { "SoNodekitCatalog_isNullByDefault", _wrap_SoNodekitCatalog_isNullByDefault, METH_VARARGS, "\n"
		"SoNodekitCatalog_isNullByDefault(SoNodekitCatalog self, int part) -> SbBool\n"
		"SoNodekitCatalog_isNullByDefault(SoNodekitCatalog self, SbName name) -> SbBool\n"
		""},
	 { "SoNodekitCatalog_isLeaf", _wrap_SoNodekitCatalog_isLeaf, METH_VARARGS, "\n"
		"SoNodekitCatalog_isLeaf(SoNodekitCatalog self, int part) -> SbBool\n"
		"SoNodekitCatalog_isLeaf(SoNodekitCatalog self, SbName name) -> SbBool\n"
		""},
	 { "SoNodekitCatalog_getParentName", _wrap_SoNodekitCatalog_getParentName, METH_VARARGS, "\n"
		"SoNodekitCatalog_getParentName(SoNodekitCatalog self, int part) -> SbName\n"
		"SoNodekitCatalog_getParentName(SoNodekitCatalog self, SbName name) -> SbName\n"
		""},
	 { "SoNodekitCatalog_getParentPartNumber", _wrap_SoNodekitCatalog_getParentPartNumber, METH_VARARGS, "\n"
		"SoNodekitCatalog_getParentPartNumber(SoNodekitCatalog self, int part) -> int\n"
		"SoNodekitCatalog_getParentPartNumber(SoNodekitCatalog self, SbName name) -> int\n"
		""},
	 { "SoNodekitCatalog_getRightSiblingName", _wrap_SoNodekitCatalog_getRightSiblingName, METH_VARARGS, "\n"
		"SoNodekitCatalog_getRightSiblingName(SoNodekitCatalog self, int part) -> SbName\n"
		"SoNodekitCatalog_getRightSiblingName(SoNodekitCatalog self, SbName name) -> SbName\n"
		""},
	 { "SoNodekitCatalog_getRightSiblingPartNumber", _wrap_SoNodekitCatalog_getRightSiblingPartNumber, METH_VARARGS, "\n"
		"SoNodekitCatalog_getRightSiblingPartNumber(SoNodekitCatalog self, int part) -> int\n"
		"SoNodekitCatalog_getRightSiblingPartNumber(SoNodekitCatalog self, SbName name) -> int\n"
		""},
	 { "SoNodekitCatalog_isList", _wrap_SoNodekitCatalog_isList, METH_VARARGS, "\n"
		"SoNodekitCatalog_isList(SoNodekitCatalog self, int part) -> SbBool\n"
		"SoNodekitCatalog_isList(SoNodekitCatalog self, SbName name) -> SbBool\n"
		""},
	 { "SoNodekitCatalog_getListContainerType", _wrap_SoNodekitCatalog_getListContainerType, METH_VARARGS, "\n"
		"SoNodekitCatalog_getListContainerType(SoNodekitCatalog self, int part) -> SoType\n"
		"SoNodekitCatalog_getListContainerType(SoNodekitCatalog self, SbName name) -> SoType\n"
		""},
	 { "SoNodekitCatalog_getListItemTypes", _wrap_SoNodekitCatalog_getListItemTypes, METH_VARARGS, "\n"
		"SoNodekitCatalog_getListItemTypes(SoNodekitCatalog self, int part) -> SoTypeList\n"
		"SoNodekitCatalog_getListItemTypes(SoNodekitCatalog self, SbName name) -> SoTypeList\n"
		""},
	 { "SoNodekitCatalog_isPublic", _wrap_SoNodekitCatalog_isPublic, METH_VARARGS, "\n"
		"SoNodekitCatalog_isPublic(SoNodekitCatalog self, int part) -> SbBool\n"
		"SoNodekitCatalog_isPublic(SoNodekitCatalog self, SbName name) -> SbBool\n"
		""},
	 { "SoNodekitCatalog_clone", _wrap_SoNodekitCatalog_clone, METH_VARARGS, "SoNodekitCatalog_clone(SoNodekitCatalog self, SoType type) -> SoNodekitCatalog"},
	 { "SoNodekitCatalog_addEntry", _wrap_SoNodekitCatalog_addEntry, METH_VARARGS, "SoNodekitCatalog_addEntry(SoNodekitCatalog self, SbName name, SoType type, SoType defaulttype, SbBool isdefaultnull, SbName parent, SbName rightsibling, SbBool islist, SoType listcontainertype, SoType listitemtype, SbBool ispublic) -> SbBool"},
	 { "SoNodekitCatalog_addListItemType", _wrap_SoNodekitCatalog_addListItemType, METH_VARARGS, "\n"
		"SoNodekitCatalog_addListItemType(SoNodekitCatalog self, int part, SoType type)\n"
		"SoNodekitCatalog_addListItemType(SoNodekitCatalog self, SbName name, SoType type)\n"
		""},
	 { "SoNodekitCatalog_narrowTypes", _wrap_SoNodekitCatalog_narrowTypes, METH_VARARGS, "SoNodekitCatalog_narrowTypes(SoNodekitCatalog self, SbName name, SoType newtype, SoType newdefaulttype)"},
	 { "SoNodekitCatalog_setNullByDefault", _wrap_SoNodekitCatalog_setNullByDefault, METH_VARARGS, "SoNodekitCatalog_setNullByDefault(SoNodekitCatalog self, SbName name, SbBool nullbydefault)"},
	 { "SoNodekitCatalog_recursiveSearch", _wrap_SoNodekitCatalog_recursiveSearch, METH_VARARGS, "SoNodekitCatalog_recursiveSearch(SoNodekitCatalog self, int part, SbName name, SoTypeList checked) -> SbBool"},
	 { "SoNodekitCatalog_printCheck", _wrap_SoNodekitCatalog_printCheck, METH_O, "SoNodekitCatalog_printCheck(SoNodekitCatalog self)"},
	 { "SoNodekitCatalog_swigregister", SoNodekitCatalog_swigregister, METH_O, NULL},
	 { "SoNodekitCatalog_swiginit", SoNodekitCatalog_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFName", _wrap_new_SoSFName, METH_NOARGS, "new_SoSFName() -> SoSFName"},
	 { "delete_SoSFName", _wrap_delete_SoSFName, METH_O, "delete_SoSFName(SoSFName self)"},
	 { "SoSFName_createInstance", _wrap_SoSFName_createInstance, METH_NOARGS, "SoSFName_createInstance() -> void *"},
	 { "SoSFName_getClassTypeId", _wrap_SoSFName_getClassTypeId, METH_NOARGS, "SoSFName_getClassTypeId() -> SoType"},
	 { "SoSFName_getTypeId", _wrap_SoSFName_getTypeId, METH_O, "SoSFName_getTypeId(SoSFName self) -> SoType"},
	 { "SoSFName_copyFrom", _wrap_SoSFName_copyFrom, METH_VARARGS, "SoSFName_copyFrom(SoSFName self, SoField field)"},
	 { "SoSFName_isSame", _wrap_SoSFName_isSame, METH_VARARGS, "SoSFName_isSame(SoSFName self, SoField field) -> SbBool"},
	 { "SoSFName_getValue", _wrap_SoSFName_getValue, METH_O, "SoSFName_getValue(SoSFName self) -> SbName"},
	 { "SoSFName___eq__", _wrap_SoSFName___eq__, METH_VARARGS, "SoSFName___eq__(SoSFName self, SoSFName field) -> int"},
	 { "SoSFName___ne__", _wrap_SoSFName___ne__, METH_VARARGS, "SoSFName___ne__(SoSFName self, SoSFName field) -> int"},
	 { "SoSFName_initClass", _wrap_SoSFName_initClass, METH_NOARGS, "SoSFName_initClass()"},
	 { "SoSFName_setValue", _wrap_SoSFName_setValue, METH_VARARGS, "\n"
		"SoSFName_setValue(SoSFName self, SbName newvalue)\n"
		"SoSFName_setValue(SoSFName self, char const *const name)\n"
		"SoSFName_setValue(SoSFName self, SoSFName other)\n"
		""},
	 { "SoSFName_swigregister", SoSFName_swigregister, METH_O, NULL},
	 { "SoSFName_swiginit", SoSFName_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFName", _wrap_new_SoMFName, METH_NOARGS, "new_SoMFName() -> SoMFName"},
	 { "delete_SoMFName", _wrap_delete_SoMFName, METH_O, "delete_SoMFName(SoMFName self)"},
	 { "SoMFName_createInstance", _wrap_SoMFName_createInstance, METH_NOARGS, "SoMFName_createInstance() -> void *"},
	 { "SoMFName_getClassTypeId", _wrap_SoMFName_getClassTypeId, METH_NOARGS, "SoMFName_getClassTypeId() -> SoType"},
	 { "SoMFName_getTypeId", _wrap_SoMFName_getTypeId, METH_O, "SoMFName_getTypeId(SoMFName self) -> SoType"},
	 { "SoMFName_copyFrom", _wrap_SoMFName_copyFrom, METH_VARARGS, "SoMFName_copyFrom(SoMFName self, SoField field)"},
	 { "SoMFName_isSame", _wrap_SoMFName_isSame, METH_VARARGS, "SoMFName_isSame(SoMFName self, SoField field) -> SbBool"},
	 { "SoMFName_find", _wrap_SoMFName_find, METH_VARARGS, "SoMFName_find(SoMFName self, SbName value, SbBool addifnotfound=0) -> int"},
	 { "SoMFName_set1Value", _wrap_SoMFName_set1Value, METH_VARARGS, "SoMFName_set1Value(SoMFName self, int const idx, SbName value)"},
	 { "SoMFName___eq__", _wrap_SoMFName___eq__, METH_VARARGS, "SoMFName___eq__(SoMFName self, SoMFName field) -> SbBool"},
	 { "SoMFName___ne__", _wrap_SoMFName___ne__, METH_VARARGS, "SoMFName___ne__(SoMFName self, SoMFName field) -> SbBool"},
	 { "SoMFName_startEditing", _wrap_SoMFName_startEditing, METH_O, "SoMFName_startEditing(SoMFName self) -> SbName"},
	 { "SoMFName_finishEditing", _wrap_SoMFName_finishEditing, METH_O, "SoMFName_finishEditing(SoMFName self)"},
	 { "SoMFName_initClass", _wrap_SoMFName_initClass, METH_NOARGS, "SoMFName_initClass()"},
	 { "SoMFName_setValues", _wrap_SoMFName_setValues, METH_VARARGS, "\n"
		"SoMFName_setValues(SoMFName self, int const start, int const num, SbName newvals)\n"
		"SoMFName_setValues(SoMFName self, int const start, int const num, char const *[] strings)\n"
		""},
	 { "SoMFName___getitem__", _wrap_SoMFName___getitem__, METH_VARARGS, "SoMFName___getitem__(SoMFName self, int i) -> SbName"},
	 { "SoMFName___setitem__", _wrap_SoMFName___setitem__, METH_VARARGS, "SoMFName___setitem__(SoMFName self, int i, SbName value)"},
	 { "SoMFName_setValue", _wrap_SoMFName_setValue, METH_VARARGS, "\n"
		"SoMFName_setValue(SoMFName self, SbName value)\n"
		"SoMFName_setValue(SoMFName self, char const * str)\n"
		"SoMFName_setValue(SoMFName self, SoMFName other)\n"
		""},
	 { "SoMFName_getValues", _wrap_SoMFName_getValues, METH_VARARGS, "SoMFName_getValues(SoMFName self, int i=0) -> SbName"},
	 { "SoMFName_swigregister", SoMFName_swigregister, METH_O, NULL},
	 { "SoMFName_swiginit", SoMFName_swiginit, METH_VARARGS, NULL},
	 { "SoNodeKitListPart_getClassTypeId", _wrap_SoNodeKitListPart_getClassTypeId, METH_NOARGS, "SoNodeKitListPart_getClassTypeId() -> SoType"},
	 { "SoNodeKitListPart_getTypeId", _wrap_SoNodeKitListPart_getTypeId, METH_O, "SoNodeKitListPart_getTypeId(SoNodeKitListPart self) -> SoType"},
	 { "SoNodeKitListPart_initClass", _wrap_SoNodeKitListPart_initClass, METH_NOARGS, "SoNodeKitListPart_initClass()"},
	 { "new_SoNodeKitListPart", _wrap_new_SoNodeKitListPart, METH_NOARGS, "new_SoNodeKitListPart() -> SoNodeKitListPart"},
	 { "SoNodeKitListPart_getContainerType", _wrap_SoNodeKitListPart_getContainerType, METH_O, "SoNodeKitListPart_getContainerType(SoNodeKitListPart self) -> SoType"},
	 { "SoNodeKitListPart_setContainerType", _wrap_SoNodeKitListPart_setContainerType, METH_VARARGS, "SoNodeKitListPart_setContainerType(SoNodeKitListPart self, SoType newContainerType)"},
	 { "SoNodeKitListPart_getChildTypes", _wrap_SoNodeKitListPart_getChildTypes, METH_O, "SoNodeKitListPart_getChildTypes(SoNodeKitListPart self) -> SoTypeList"},
	 { "SoNodeKitListPart_addChildType", _wrap_SoNodeKitListPart_addChildType, METH_VARARGS, "SoNodeKitListPart_addChildType(SoNodeKitListPart self, SoType typeToAdd)"},
	 { "SoNodeKitListPart_isTypePermitted", _wrap_SoNodeKitListPart_isTypePermitted, METH_VARARGS, "SoNodeKitListPart_isTypePermitted(SoNodeKitListPart self, SoType typeToCheck) -> SbBool"},
	 { "SoNodeKitListPart_isChildPermitted", _wrap_SoNodeKitListPart_isChildPermitted, METH_VARARGS, "SoNodeKitListPart_isChildPermitted(SoNodeKitListPart self, SoNode child) -> SbBool"},
	 { "SoNodeKitListPart_containerSet", _wrap_SoNodeKitListPart_containerSet, METH_VARARGS, "SoNodeKitListPart_containerSet(SoNodeKitListPart self, char const * fieldDataString)"},
	 { "SoNodeKitListPart_lockTypes", _wrap_SoNodeKitListPart_lockTypes, METH_O, "SoNodeKitListPart_lockTypes(SoNodeKitListPart self)"},
	 { "SoNodeKitListPart_isTypeLocked", _wrap_SoNodeKitListPart_isTypeLocked, METH_O, "SoNodeKitListPart_isTypeLocked(SoNodeKitListPart self) -> SbBool"},
	 { "SoNodeKitListPart_addChild", _wrap_SoNodeKitListPart_addChild, METH_VARARGS, "SoNodeKitListPart_addChild(SoNodeKitListPart self, SoNode child)"},
	 { "SoNodeKitListPart_insertChild", _wrap_SoNodeKitListPart_insertChild, METH_VARARGS, "SoNodeKitListPart_insertChild(SoNodeKitListPart self, SoNode child, int childIndex)"},
	 { "SoNodeKitListPart_getChild", _wrap_SoNodeKitListPart_getChild, METH_VARARGS, "SoNodeKitListPart_getChild(SoNodeKitListPart self, int index) -> SoNode"},
	 { "SoNodeKitListPart_findChild", _wrap_SoNodeKitListPart_findChild, METH_VARARGS, "SoNodeKitListPart_findChild(SoNodeKitListPart self, SoNode child) -> int"},
	 { "SoNodeKitListPart_getNumChildren", _wrap_SoNodeKitListPart_getNumChildren, METH_O, "SoNodeKitListPart_getNumChildren(SoNodeKitListPart self) -> int"},
	 { "SoNodeKitListPart_removeChild", _wrap_SoNodeKitListPart_removeChild, METH_VARARGS, "\n"
		"SoNodeKitListPart_removeChild(SoNodeKitListPart self, int index)\n"
		"SoNodeKitListPart_removeChild(SoNodeKitListPart self, SoNode child)\n"
		""},
	 { "SoNodeKitListPart_replaceChild", _wrap_SoNodeKitListPart_replaceChild, METH_VARARGS, "\n"
		"SoNodeKitListPart_replaceChild(SoNodeKitListPart self, int index, SoNode newChild)\n"
		"SoNodeKitListPart_replaceChild(SoNodeKitListPart self, SoNode oldChild, SoNode newChild)\n"
		""},
	 { "SoNodeKitListPart_affectsState", _wrap_SoNodeKitListPart_affectsState, METH_O, "SoNodeKitListPart_affectsState(SoNodeKitListPart self) -> SbBool"},
	 { "SoNodeKitListPart_doAction", _wrap_SoNodeKitListPart_doAction, METH_VARARGS, "SoNodeKitListPart_doAction(SoNodeKitListPart self, SoAction action)"},
	 { "SoNodeKitListPart_callback", _wrap_SoNodeKitListPart_callback, METH_VARARGS, "SoNodeKitListPart_callback(SoNodeKitListPart self, SoCallbackAction action)"},
	 { "SoNodeKitListPart_GLRender", _wrap_SoNodeKitListPart_GLRender, METH_VARARGS, "SoNodeKitListPart_GLRender(SoNodeKitListPart self, SoGLRenderAction action)"},
	 { "SoNodeKitListPart_getBoundingBox", _wrap_SoNodeKitListPart_getBoundingBox, METH_VARARGS, "SoNodeKitListPart_getBoundingBox(SoNodeKitListPart self, SoGetBoundingBoxAction action)"},
	 { "SoNodeKitListPart_getMatrix", _wrap_SoNodeKitListPart_getMatrix, METH_VARARGS, "SoNodeKitListPart_getMatrix(SoNodeKitListPart self, SoGetMatrixAction action)"},
	 { "SoNodeKitListPart_handleEvent", _wrap_SoNodeKitListPart_handleEvent, METH_VARARGS, "SoNodeKitListPart_handleEvent(SoNodeKitListPart self, SoHandleEventAction action)"},
	 { "SoNodeKitListPart_pick", _wrap_SoNodeKitListPart_pick, METH_VARARGS, "SoNodeKitListPart_pick(SoNodeKitListPart self, SoPickAction action)"},
	 { "SoNodeKitListPart_search", _wrap_SoNodeKitListPart_search, METH_VARARGS, "SoNodeKitListPart_search(SoNodeKitListPart self, SoSearchAction action)"},
	 { "SoNodeKitListPart_getPrimitiveCount", _wrap_SoNodeKitListPart_getPrimitiveCount, METH_VARARGS, "SoNodeKitListPart_getPrimitiveCount(SoNodeKitListPart self, SoGetPrimitiveCountAction action)"},
	 { "SoNodeKitListPart_getChildren", _wrap_SoNodeKitListPart_getChildren, METH_O, "SoNodeKitListPart_getChildren(SoNodeKitListPart self) -> SoChildList"},
	 { "SoNodeKitListPart_swigregister", SoNodeKitListPart_swigregister, METH_O, NULL},
	 { "SoNodeKitListPart_swiginit", SoNodeKitListPart_swiginit, METH_VARARGS, NULL},
	 { "SoNodeKitPath_getLength", _wrap_SoNodeKitPath_getLength, METH_O, "SoNodeKitPath_getLength(SoNodeKitPath self) -> int"},
	 { "SoNodeKitPath_getTail", _wrap_SoNodeKitPath_getTail, METH_O, "SoNodeKitPath_getTail(SoNodeKitPath self) -> SoNode"},
	 { "SoNodeKitPath_getNode", _wrap_SoNodeKitPath_getNode, METH_VARARGS, "SoNodeKitPath_getNode(SoNodeKitPath self, int const idx) -> SoNode"},
	 { "SoNodeKitPath_getNodeFromTail", _wrap_SoNodeKitPath_getNodeFromTail, METH_VARARGS, "SoNodeKitPath_getNodeFromTail(SoNodeKitPath self, int const idx) -> SoNode"},
	 { "SoNodeKitPath_truncate", _wrap_SoNodeKitPath_truncate, METH_VARARGS, "SoNodeKitPath_truncate(SoNodeKitPath self, int const length)"},
	 { "SoNodeKitPath_pop", _wrap_SoNodeKitPath_pop, METH_O, "SoNodeKitPath_pop(SoNodeKitPath self)"},
	 { "SoNodeKitPath_append", _wrap_SoNodeKitPath_append, METH_VARARGS, "\n"
		"SoNodeKitPath_append(SoNodeKitPath self, SoBaseKit childKit)\n"
		"SoNodeKitPath_append(SoNodeKitPath self, SoNodeKitPath fromPath)\n"
		""},
	 { "SoNodeKitPath_containsNode", _wrap_SoNodeKitPath_containsNode, METH_VARARGS, "SoNodeKitPath_containsNode(SoNodeKitPath self, SoBaseKit node) -> SbBool"},
	 { "SoNodeKitPath_findFork", _wrap_SoNodeKitPath_findFork, METH_VARARGS, "SoNodeKitPath_findFork(SoNodeKitPath self, SoNodeKitPath path) -> int"},
	 { "SoNodeKitPath___eq__", _wrap_SoNodeKitPath___eq__, METH_VARARGS, "SoNodeKitPath___eq__(SoNodeKitPath self, SoNodeKitPath u) -> int"},
	 { "SoNodeKitPath___nq__", _wrap_SoNodeKitPath___nq__, METH_VARARGS, "SoNodeKitPath___nq__(SoNodeKitPath self, SoNodeKitPath u) -> int"},
	 { "SoNodeKitPath_swigregister", SoNodeKitPath_swigregister, METH_O, NULL},
	 { "new_SoChildList", _wrap_new_SoChildList, METH_VARARGS, "\n"
		"SoChildList(SoNode parent)\n"
		"SoChildList(SoNode parent, int const size)\n"
		"new_SoChildList(SoNode parent, SoChildList cl) -> SoChildList\n"
		""},
	 { "delete_SoChildList", _wrap_delete_SoChildList, METH_O, "delete_SoChildList(SoChildList self)"},
	 { "SoChildList_append", _wrap_SoChildList_append, METH_VARARGS, "SoChildList_append(SoChildList self, SoNode node)"},
	 { "SoChildList_insert", _wrap_SoChildList_insert, METH_VARARGS, "SoChildList_insert(SoChildList self, SoNode ptr, int const addbefore)"},
	 { "SoChildList_remove", _wrap_SoChildList_remove, METH_VARARGS, "SoChildList_remove(SoChildList self, int const index)"},
	 { "SoChildList_truncate", _wrap_SoChildList_truncate, METH_VARARGS, "SoChildList_truncate(SoChildList self, int const length)"},
	 { "SoChildList_copy", _wrap_SoChildList_copy, METH_VARARGS, "SoChildList_copy(SoChildList self, SoChildList cl)"},
	 { "SoChildList_set", _wrap_SoChildList_set, METH_VARARGS, "SoChildList_set(SoChildList self, int const index, SoNode node)"},
	 { "SoChildList_traverseInPath", _wrap_SoChildList_traverseInPath, METH_VARARGS, "SoChildList_traverseInPath(SoChildList self, SoAction action, int const numindices, int const * indices)"},
	 { "SoChildList_traverse", _wrap_SoChildList_traverse, METH_VARARGS, "\n"
		"SoChildList_traverse(SoChildList self, SoAction action)\n"
		"SoChildList_traverse(SoChildList self, SoAction action, int const index)\n"
		"SoChildList_traverse(SoChildList self, SoAction action, SoNode node)\n"
		"SoChildList_traverse(SoChildList self, SoAction action, int const first, int const last)\n"
		""},
	 { "SoChildList_addPathAuditor", _wrap_SoChildList_addPathAuditor, METH_VARARGS, "SoChildList_addPathAuditor(SoChildList self, SoPath path)"},
	 { "SoChildList_removePathAuditor", _wrap_SoChildList_removePathAuditor, METH_VARARGS, "SoChildList_removePathAuditor(SoChildList self, SoPath path)"},
	 { "SoChildList_swigregister", SoChildList_swigregister, METH_O, NULL},
	 { "SoChildList_swiginit", SoChildList_swiginit, METH_VARARGS, NULL},
	 { "SoBaseKit_getClassTypeId", _wrap_SoBaseKit_getClassTypeId, METH_NOARGS, "SoBaseKit_getClassTypeId() -> SoType"},
	 { "SoBaseKit_getTypeId", _wrap_SoBaseKit_getTypeId, METH_O, "SoBaseKit_getTypeId(SoBaseKit self) -> SoType"},
	 { "SoBaseKit_initClass", _wrap_SoBaseKit_initClass, METH_NOARGS, "SoBaseKit_initClass()"},
	 { "new_SoBaseKit", _wrap_new_SoBaseKit, METH_NOARGS, "new_SoBaseKit() -> SoBaseKit"},
	 { "SoBaseKit_getClassNodekitCatalog", _wrap_SoBaseKit_getClassNodekitCatalog, METH_NOARGS, "SoBaseKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoBaseKit_getNodekitCatalog", _wrap_SoBaseKit_getNodekitCatalog, METH_O, "SoBaseKit_getNodekitCatalog(SoBaseKit self) -> SoNodekitCatalog"},
	 { "SoBaseKit_getPart", _wrap_SoBaseKit_getPart, METH_VARARGS, "SoBaseKit_getPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNode"},
	 { "SoBaseKit_getPartString", _wrap_SoBaseKit_getPartString, METH_VARARGS, "SoBaseKit_getPartString(SoBaseKit self, SoBase part) -> SbString"},
	 { "SoBaseKit_createPathToPart", _wrap_SoBaseKit_createPathToPart, METH_VARARGS, "SoBaseKit_createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded, SoPath pathtoextend=None) -> SoNodeKitPath"},
	 { "SoBaseKit_setPart", _wrap_SoBaseKit_setPart, METH_VARARGS, "SoBaseKit_setPart(SoBaseKit self, SbName partname, SoNode srcFrom) -> SbBool"},
	 { "SoBaseKit_set", _wrap_SoBaseKit_set, METH_VARARGS, "\n"
		"SoBaseKit_set(SoBaseKit self, char const * namevaluepairliststring) -> SbBool\n"
		"SoBaseKit_set(SoBaseKit self, char const * partnamestring, char const * parameterstring) -> SbBool\n"
		""},
	 { "SoBaseKit_doAction", _wrap_SoBaseKit_doAction, METH_VARARGS, "SoBaseKit_doAction(SoBaseKit self, SoAction action)"},
	 { "SoBaseKit_callback", _wrap_SoBaseKit_callback, METH_VARARGS, "SoBaseKit_callback(SoBaseKit self, SoCallbackAction action)"},
	 { "SoBaseKit_GLRender", _wrap_SoBaseKit_GLRender, METH_VARARGS, "SoBaseKit_GLRender(SoBaseKit self, SoGLRenderAction action)"},
	 { "SoBaseKit_getBoundingBox", _wrap_SoBaseKit_getBoundingBox, METH_VARARGS, "SoBaseKit_getBoundingBox(SoBaseKit self, SoGetBoundingBoxAction action)"},
	 { "SoBaseKit_getMatrix", _wrap_SoBaseKit_getMatrix, METH_VARARGS, "SoBaseKit_getMatrix(SoBaseKit self, SoGetMatrixAction action)"},
	 { "SoBaseKit_handleEvent", _wrap_SoBaseKit_handleEvent, METH_VARARGS, "SoBaseKit_handleEvent(SoBaseKit self, SoHandleEventAction action)"},
	 { "SoBaseKit_rayPick", _wrap_SoBaseKit_rayPick, METH_VARARGS, "SoBaseKit_rayPick(SoBaseKit self, SoRayPickAction action)"},
	 { "SoBaseKit_search", _wrap_SoBaseKit_search, METH_VARARGS, "SoBaseKit_search(SoBaseKit self, SoSearchAction action)"},
	 { "SoBaseKit_write", _wrap_SoBaseKit_write, METH_VARARGS, "SoBaseKit_write(SoBaseKit self, SoWriteAction action)"},
	 { "SoBaseKit_getPrimitiveCount", _wrap_SoBaseKit_getPrimitiveCount, METH_VARARGS, "SoBaseKit_getPrimitiveCount(SoBaseKit self, SoGetPrimitiveCountAction action)"},
	 { "SoBaseKit_getChildren", _wrap_SoBaseKit_getChildren, METH_O, "SoBaseKit_getChildren(SoBaseKit self) -> SoChildList"},
	 { "SoBaseKit_printDiagram", _wrap_SoBaseKit_printDiagram, METH_O, "SoBaseKit_printDiagram(SoBaseKit self)"},
	 { "SoBaseKit_printSubDiagram", _wrap_SoBaseKit_printSubDiagram, METH_VARARGS, "SoBaseKit_printSubDiagram(SoBaseKit self, SbName rootname, int level)"},
	 { "SoBaseKit_printTable", _wrap_SoBaseKit_printTable, METH_O, "SoBaseKit_printTable(SoBaseKit self)"},
	 { "SoBaseKit_addWriteReference", _wrap_SoBaseKit_addWriteReference, METH_VARARGS, "SoBaseKit_addWriteReference(SoBaseKit self, SoOutput out, SbBool isfromfield=0)"},
	 { "SoBaseKit_forceChildDrivenWriteRefs", _wrap_SoBaseKit_forceChildDrivenWriteRefs, METH_VARARGS, "SoBaseKit_forceChildDrivenWriteRefs(SoBaseKit self, SoOutput out) -> SbBool"},
	 { "SoBaseKit_isSearchingChildren", _wrap_SoBaseKit_isSearchingChildren, METH_NOARGS, "SoBaseKit_isSearchingChildren() -> SbBool"},
	 { "SoBaseKit_setSearchingChildren", _wrap_SoBaseKit_setSearchingChildren, METH_O, "SoBaseKit_setSearchingChildren(SbBool const newval)"},
	 { "SoBaseKit_swigregister", SoBaseKit_swigregister, METH_O, NULL},
	 { "SoBaseKit_swiginit", SoBaseKit_swiginit, METH_VARARGS, NULL},
	 { "delete_SoSensor", _wrap_delete_SoSensor, METH_O, "delete_SoSensor(SoSensor self)"},
	 { "SoSensor_setFunction", _wrap_SoSensor_setFunction, METH_VARARGS, "SoSensor_setFunction(SoSensor self, SoSensorCB * callbackfunction)"},
	 { "SoSensor_getFunction", _wrap_SoSensor_getFunction, METH_O, "SoSensor_getFunction(SoSensor self) -> SoSensorCBPtr"},
	 { "SoSensor_setData", _wrap_SoSensor_setData, METH_VARARGS, "SoSensor_setData(SoSensor self, void * callbackdata)"},
	 { "SoSensor_getData", _wrap_SoSensor_getData, METH_O, "SoSensor_getData(SoSensor self) -> void *"},
	 { "SoSensor_schedule", _wrap_SoSensor_schedule, METH_O, "SoSensor_schedule(SoSensor self)"},
	 { "SoSensor_unschedule", _wrap_SoSensor_unschedule, METH_O, "SoSensor_unschedule(SoSensor self)"},
	 { "SoSensor_isScheduled", _wrap_SoSensor_isScheduled, METH_O, "SoSensor_isScheduled(SoSensor self) -> SbBool"},
	 { "SoSensor_trigger", _wrap_SoSensor_trigger, METH_O, "SoSensor_trigger(SoSensor self)"},
	 { "SoSensor_isBefore", _wrap_SoSensor_isBefore, METH_VARARGS, "SoSensor_isBefore(SoSensor self, SoSensor s) -> SbBool"},
	 { "SoSensor_setNextInQueue", _wrap_SoSensor_setNextInQueue, METH_VARARGS, "SoSensor_setNextInQueue(SoSensor self, SoSensor next)"},
	 { "SoSensor_getNextInQueue", _wrap_SoSensor_getNextInQueue, METH_O, "SoSensor_getNextInQueue(SoSensor self) -> SoSensor"},
	 { "SoSensor_initClass", _wrap_SoSensor_initClass, METH_NOARGS, "SoSensor_initClass()"},
	 { "SoSensor_swigregister", SoSensor_swigregister, METH_O, NULL},
	 { "new_SoDelayQueueSensor", _wrap_new_SoDelayQueueSensor, METH_NOARGS, "new_SoDelayQueueSensor() -> SoDelayQueueSensor"},
	 { "new_SoDelayQueueSensor_scb_v", _wrap_new_SoDelayQueueSensor_scb_v, METH_VARARGS, "new_SoDelayQueueSensor_scb_v(SoSensorCB * func, void * data) -> SoDelayQueueSensor"},
	 { "delete_SoDelayQueueSensor", _wrap_delete_SoDelayQueueSensor, METH_O, "delete_SoDelayQueueSensor(SoDelayQueueSensor self)"},
	 { "SoDelayQueueSensor_setPriority", _wrap_SoDelayQueueSensor_setPriority, METH_VARARGS, "SoDelayQueueSensor_setPriority(SoDelayQueueSensor self, uint32_t pri)"},
	 { "SoDelayQueueSensor_getPriority", _wrap_SoDelayQueueSensor_getPriority, METH_O, "SoDelayQueueSensor_getPriority(SoDelayQueueSensor self) -> uint32_t"},
	 { "SoDelayQueueSensor_getDefaultPriority", _wrap_SoDelayQueueSensor_getDefaultPriority, METH_NOARGS, "SoDelayQueueSensor_getDefaultPriority() -> uint32_t"},
	 { "SoDelayQueueSensor_schedule", _wrap_SoDelayQueueSensor_schedule, METH_O, "SoDelayQueueSensor_schedule(SoDelayQueueSensor self)"},
	 { "SoDelayQueueSensor_unschedule", _wrap_SoDelayQueueSensor_unschedule, METH_O, "SoDelayQueueSensor_unschedule(SoDelayQueueSensor self)"},
	 { "SoDelayQueueSensor_isScheduled", _wrap_SoDelayQueueSensor_isScheduled, METH_O, "SoDelayQueueSensor_isScheduled(SoDelayQueueSensor self) -> SbBool"},
	 { "SoDelayQueueSensor_isIdleOnly", _wrap_SoDelayQueueSensor_isIdleOnly, METH_O, "SoDelayQueueSensor_isIdleOnly(SoDelayQueueSensor self) -> SbBool"},
	 { "SoDelayQueueSensor_trigger", _wrap_SoDelayQueueSensor_trigger, METH_O, "SoDelayQueueSensor_trigger(SoDelayQueueSensor self)"},
	 { "SoDelayQueueSensor_swigregister", SoDelayQueueSensor_swigregister, METH_O, NULL},
	 { "SoDelayQueueSensor_swiginit", SoDelayQueueSensor_swiginit, METH_VARARGS, NULL},
	 { "delete_SoDataSensor", _wrap_delete_SoDataSensor, METH_O, "delete_SoDataSensor(SoDataSensor self)"},
	 { "SoDataSensor_setDeleteCallback", _wrap_SoDataSensor_setDeleteCallback, METH_VARARGS, "SoDataSensor_setDeleteCallback(SoDataSensor self, SoSensorCB * function, void * data=None)"},
	 { "SoDataSensor_getTriggerNode", _wrap_SoDataSensor_getTriggerNode, METH_O, "SoDataSensor_getTriggerNode(SoDataSensor self) -> SoNode"},
	 { "SoDataSensor_getTriggerField", _wrap_SoDataSensor_getTriggerField, METH_O, "SoDataSensor_getTriggerField(SoDataSensor self) -> SoField"},
	 { "SoDataSensor_getTriggerPath", _wrap_SoDataSensor_getTriggerPath, METH_O, "SoDataSensor_getTriggerPath(SoDataSensor self) -> SoPath"},
	 { "SoDataSensor_setTriggerPathFlag", _wrap_SoDataSensor_setTriggerPathFlag, METH_VARARGS, "SoDataSensor_setTriggerPathFlag(SoDataSensor self, SbBool flag)"},
	 { "SoDataSensor_getTriggerPathFlag", _wrap_SoDataSensor_getTriggerPathFlag, METH_O, "SoDataSensor_getTriggerPathFlag(SoDataSensor self) -> SbBool"},
	 { "SoDataSensor_getTriggerOperationType", _wrap_SoDataSensor_getTriggerOperationType, METH_O, "SoDataSensor_getTriggerOperationType(SoDataSensor self) -> SoNotRec::OperationType"},
	 { "SoDataSensor_getTriggerIndex", _wrap_SoDataSensor_getTriggerIndex, METH_O, "SoDataSensor_getTriggerIndex(SoDataSensor self) -> int"},
	 { "SoDataSensor_getTriggerFieldNumIndices", _wrap_SoDataSensor_getTriggerFieldNumIndices, METH_O, "SoDataSensor_getTriggerFieldNumIndices(SoDataSensor self) -> int"},
	 { "SoDataSensor_getTriggerGroupChild", _wrap_SoDataSensor_getTriggerGroupChild, METH_O, "SoDataSensor_getTriggerGroupChild(SoDataSensor self) -> SoNode"},
	 { "SoDataSensor_getTriggerReplacedGroupChild", _wrap_SoDataSensor_getTriggerReplacedGroupChild, METH_O, "SoDataSensor_getTriggerReplacedGroupChild(SoDataSensor self) -> SoNode"},
	 { "SoDataSensor_trigger", _wrap_SoDataSensor_trigger, METH_O, "SoDataSensor_trigger(SoDataSensor self)"},
	 { "SoDataSensor_notify", _wrap_SoDataSensor_notify, METH_VARARGS, "SoDataSensor_notify(SoDataSensor self, SoNotList l)"},
	 { "SoDataSensor_dyingReference", _wrap_SoDataSensor_dyingReference, METH_O, "SoDataSensor_dyingReference(SoDataSensor self)"},
	 { "SoDataSensor_swigregister", SoDataSensor_swigregister, METH_O, NULL},
	 { "new_SoFieldSensor", _wrap_new_SoFieldSensor, METH_NOARGS, "new_SoFieldSensor() -> SoFieldSensor"},
	 { "new_SoFieldSensor_scb_v", _wrap_new_SoFieldSensor_scb_v, METH_VARARGS, "new_SoFieldSensor_scb_v(SoSensorCB * func, void * data) -> SoFieldSensor"},
	 { "delete_SoFieldSensor", _wrap_delete_SoFieldSensor, METH_O, "delete_SoFieldSensor(SoFieldSensor self)"},
	 { "SoFieldSensor_attach", _wrap_SoFieldSensor_attach, METH_VARARGS, "SoFieldSensor_attach(SoFieldSensor self, SoField field)"},
	 { "SoFieldSensor_detach", _wrap_SoFieldSensor_detach, METH_O, "SoFieldSensor_detach(SoFieldSensor self)"},
	 { "SoFieldSensor_getAttachedField", _wrap_SoFieldSensor_getAttachedField, METH_O, "SoFieldSensor_getAttachedField(SoFieldSensor self) -> SoField"},
	 { "SoFieldSensor_trigger", _wrap_SoFieldSensor_trigger, METH_O, "SoFieldSensor_trigger(SoFieldSensor self)"},
	 { "SoFieldSensor_swigregister", SoFieldSensor_swigregister, METH_O, NULL},
	 { "SoFieldSensor_swiginit", SoFieldSensor_swiginit, METH_VARARGS, NULL},
	 { "SoInteractionKit_getClassTypeId", _wrap_SoInteractionKit_getClassTypeId, METH_NOARGS, "SoInteractionKit_getClassTypeId() -> SoType"},
	 { "SoInteractionKit_getTypeId", _wrap_SoInteractionKit_getTypeId, METH_O, "SoInteractionKit_getTypeId(SoInteractionKit self) -> SoType"},
	 { "SoInteractionKit_getClassNodekitCatalog", _wrap_SoInteractionKit_getClassNodekitCatalog, METH_NOARGS, "SoInteractionKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoInteractionKit_getNodekitCatalog", _wrap_SoInteractionKit_getNodekitCatalog, METH_O, "SoInteractionKit_getNodekitCatalog(SoInteractionKit self) -> SoNodekitCatalog"},
	 { "SoInteractionKit_renderCaching_set", _wrap_SoInteractionKit_renderCaching_set, METH_VARARGS, "SoInteractionKit_renderCaching_set(SoInteractionKit self, SoSFEnum renderCaching)"},
	 { "SoInteractionKit_renderCaching_get", _wrap_SoInteractionKit_renderCaching_get, METH_O, "SoInteractionKit_renderCaching_get(SoInteractionKit self) -> SoSFEnum"},
	 { "SoInteractionKit_boundingBoxCaching_set", _wrap_SoInteractionKit_boundingBoxCaching_set, METH_VARARGS, "SoInteractionKit_boundingBoxCaching_set(SoInteractionKit self, SoSFEnum boundingBoxCaching)"},
	 { "SoInteractionKit_boundingBoxCaching_get", _wrap_SoInteractionKit_boundingBoxCaching_get, METH_O, "SoInteractionKit_boundingBoxCaching_get(SoInteractionKit self) -> SoSFEnum"},
	 { "SoInteractionKit_renderCulling_set", _wrap_SoInteractionKit_renderCulling_set, METH_VARARGS, "SoInteractionKit_renderCulling_set(SoInteractionKit self, SoSFEnum renderCulling)"},
	 { "SoInteractionKit_renderCulling_get", _wrap_SoInteractionKit_renderCulling_get, METH_O, "SoInteractionKit_renderCulling_get(SoInteractionKit self) -> SoSFEnum"},
	 { "SoInteractionKit_pickCulling_set", _wrap_SoInteractionKit_pickCulling_set, METH_VARARGS, "SoInteractionKit_pickCulling_set(SoInteractionKit self, SoSFEnum pickCulling)"},
	 { "SoInteractionKit_pickCulling_get", _wrap_SoInteractionKit_pickCulling_get, METH_O, "SoInteractionKit_pickCulling_get(SoInteractionKit self) -> SoSFEnum"},
	 { "new_SoInteractionKit", _wrap_new_SoInteractionKit, METH_NOARGS, "new_SoInteractionKit() -> SoInteractionKit"},
	 { "SoInteractionKit_initClass", _wrap_SoInteractionKit_initClass, METH_NOARGS, "SoInteractionKit_initClass()"},
	 { "SoInteractionKit_setPartAsPath", _wrap_SoInteractionKit_setPartAsPath, METH_VARARGS, "SoInteractionKit_setPartAsPath(SoInteractionKit self, SbName partname, SoPath path) -> SbBool"},
	 { "SoInteractionKit_setPartAsDefault", _wrap_SoInteractionKit_setPartAsDefault, METH_VARARGS, "\n"
		"SoInteractionKit_setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node, SbBool onlyifdefault=1) -> SbBool\n"
		"SoInteractionKit_setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename, SbBool onlyifdefault=1) -> SbBool\n"
		""},
	 { "SoInteractionKit_isPathSurrogateInMySubgraph", _wrap_SoInteractionKit_isPathSurrogateInMySubgraph, METH_VARARGS, "\n"
		"SoInteractionKit_isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath, SbBool fillargs=1) -> SbBool\n"
		"SoInteractionKit_isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path) -> SbBool\n"
		""},
	 { "SoInteractionKit_setSwitchValue", _wrap_SoInteractionKit_setSwitchValue, METH_VARARGS, "SoInteractionKit_setSwitchValue(SoNode node, int const newVal)"},
	 { "SoInteractionKit_setPart", _wrap_SoInteractionKit_setPart, METH_VARARGS, "SoInteractionKit_setPart(SoInteractionKit self, SbName partname, SoNode srcFrom) -> SbBool"},
	 { "SoInteractionKit_swigregister", SoInteractionKit_swigregister, METH_O, NULL},
	 { "SoInteractionKit_swiginit", SoInteractionKit_swiginit, METH_VARARGS, NULL},
	 { "new_SoCallbackList", _wrap_new_SoCallbackList, METH_NOARGS, "new_SoCallbackList() -> SoCallbackList"},
	 { "delete_SoCallbackList", _wrap_delete_SoCallbackList, METH_O, "delete_SoCallbackList(SoCallbackList self)"},
	 { "SoCallbackList_addCallback", _wrap_SoCallbackList_addCallback, METH_VARARGS, "SoCallbackList_addCallback(SoCallbackList self, SoCallbackListCB * f, void * userData=None)"},
	 { "SoCallbackList_removeCallback", _wrap_SoCallbackList_removeCallback, METH_VARARGS, "SoCallbackList_removeCallback(SoCallbackList self, SoCallbackListCB * f, void * userdata=None)"},
	 { "SoCallbackList_clearCallbacks", _wrap_SoCallbackList_clearCallbacks, METH_O, "SoCallbackList_clearCallbacks(SoCallbackList self)"},
	 { "SoCallbackList_getNumCallbacks", _wrap_SoCallbackList_getNumCallbacks, METH_O, "SoCallbackList_getNumCallbacks(SoCallbackList self) -> int"},
	 { "SoCallbackList_invokeCallbacks", _wrap_SoCallbackList_invokeCallbacks, METH_VARARGS, "SoCallbackList_invokeCallbacks(SoCallbackList self, void * callbackdata)"},
	 { "SoCallbackList_swigregister", SoCallbackList_swigregister, METH_O, NULL},
	 { "SoCallbackList_swiginit", SoCallbackList_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec3d", _wrap_new_SbVec3d, METH_VARARGS, "\n"
		"SbVec3d()\n"
		"SbVec3d(double const [3] v)\n"
		"SbVec3d(double x, double y, double z)\n"
		"SbVec3d(SbVec3f v)\n"
		"SbVec3d(SbVec3b v)\n"
		"SbVec3d(SbVec3s v)\n"
		"SbVec3d(SbVec3i32 v)\n"
		"new_SbVec3d(SbDPPlane p0, SbDPPlane p1, SbDPPlane p2) -> SbVec3d\n"
		""},
	 { "SbVec3d_setValue", _wrap_SbVec3d_setValue, METH_VARARGS, "\n"
		"SbVec3d_setValue(SbVec3d self, double const [3] v) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, double x, double y, double z) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, SbVec3d barycentric, SbVec3d v0, SbVec3d v1, SbVec3d v2) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, SbVec3f v) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, SbVec3b v) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, SbVec3s v) -> SbVec3d\n"
		"SbVec3d_setValue(SbVec3d self, SbVec3i32 v) -> SbVec3d\n"
		""},
	 { "SbVec3d_getValue", _wrap_SbVec3d_getValue, METH_O, "SbVec3d_getValue(SbVec3d self) -> double const *"},
	 { "SbVec3d_cross", _wrap_SbVec3d_cross, METH_VARARGS, "SbVec3d_cross(SbVec3d self, SbVec3d v) -> SbVec3d"},
	 { "SbVec3d_dot", _wrap_SbVec3d_dot, METH_VARARGS, "SbVec3d_dot(SbVec3d self, SbVec3d v) -> double"},
	 { "SbVec3d_equals", _wrap_SbVec3d_equals, METH_VARARGS, "SbVec3d_equals(SbVec3d self, SbVec3d v, double tolerance) -> SbBool"},
	 { "SbVec3d_getClosestAxis", _wrap_SbVec3d_getClosestAxis, METH_O, "SbVec3d_getClosestAxis(SbVec3d self) -> SbVec3d"},
	 { "SbVec3d_length", _wrap_SbVec3d_length, METH_O, "SbVec3d_length(SbVec3d self) -> double"},
	 { "SbVec3d_sqrLength", _wrap_SbVec3d_sqrLength, METH_O, "SbVec3d_sqrLength(SbVec3d self) -> double"},
	 { "SbVec3d_negate", _wrap_SbVec3d_negate, METH_O, "SbVec3d_negate(SbVec3d self)"},
	 { "SbVec3d_normalize", _wrap_SbVec3d_normalize, METH_O, "SbVec3d_normalize(SbVec3d self) -> double"},
	 { "SbVec3d___imul__", _wrap_SbVec3d___imul__, METH_VARARGS, "SbVec3d___imul__(SbVec3d self, double d) -> SbVec3d"},
	 { "SbVec3d___itruediv__", _wrap_SbVec3d___itruediv__, METH_VARARGS, "SbVec3d___itruediv__(SbVec3d self, double d) -> SbVec3d"},
	 { "SbVec3d___iadd__", _wrap_SbVec3d___iadd__, METH_VARARGS, "SbVec3d___iadd__(SbVec3d self, SbVec3d v) -> SbVec3d"},
	 { "SbVec3d___isub__", _wrap_SbVec3d___isub__, METH_VARARGS, "SbVec3d___isub__(SbVec3d self, SbVec3d v) -> SbVec3d"},
	 { "SbVec3d___neg__", _wrap_SbVec3d___neg__, METH_O, "SbVec3d___neg__(SbVec3d self) -> SbVec3d"},
	 { "SbVec3d_toString", _wrap_SbVec3d_toString, METH_O, "SbVec3d_toString(SbVec3d self) -> SbString"},
	 { "SbVec3d_fromString", _wrap_SbVec3d_fromString, METH_VARARGS, "SbVec3d_fromString(SbVec3d self, SbString str) -> SbBool"},
	 { "SbVec3d_output", _wrap_SbVec3d_output, METH_VARARGS, "SbVec3d_output(SbVec3d self, FILE * fp)"},
	 { "SbVec3d___add__", _wrap_SbVec3d___add__, METH_VARARGS, "SbVec3d___add__(SbVec3d self, SbVec3d u) -> SbVec3d"},
	 { "SbVec3d___sub__", _wrap_SbVec3d___sub__, METH_VARARGS, "SbVec3d___sub__(SbVec3d self, SbVec3d u) -> SbVec3d"},
	 { "SbVec3d___mul__", _wrap_SbVec3d___mul__, METH_VARARGS, "\n"
		"SbVec3d___mul__(SbVec3d self, double const d) -> SbVec3d\n"
		"SbVec3d___mul__(SbVec3d self, SbDPMatrix m) -> SbVec3d\n"
		""},
	 { "SbVec3d___rmul__", _wrap_SbVec3d___rmul__, METH_VARARGS, "SbVec3d___rmul__(SbVec3d self, double const d) -> SbVec3d"},
	 { "SbVec3d___div__", _wrap_SbVec3d___div__, METH_VARARGS, "SbVec3d___div__(SbVec3d self, double const d) -> SbVec3d"},
	 { "SbVec3d___truediv__", _wrap_SbVec3d___truediv__, METH_VARARGS, "SbVec3d___truediv__(SbVec3d self, double const d) -> SbVec3d"},
	 { "SbVec3d___eq__", _wrap_SbVec3d___eq__, METH_VARARGS, "SbVec3d___eq__(SbVec3d self, SbVec3d u) -> int"},
	 { "SbVec3d___nq__", _wrap_SbVec3d___nq__, METH_VARARGS, "SbVec3d___nq__(SbVec3d self, SbVec3d u) -> int"},
	 { "SbVec3d___getitem__", _wrap_SbVec3d___getitem__, METH_VARARGS, "SbVec3d___getitem__(SbVec3d self, int i) -> double"},
	 { "SbVec3d___setitem__", _wrap_SbVec3d___setitem__, METH_VARARGS, "SbVec3d___setitem__(SbVec3d self, int i, double value)"},
	 { "delete_SbVec3d", _wrap_delete_SbVec3d, METH_O, "delete_SbVec3d(SbVec3d self)"},
	 { "SbVec3d_swigregister", SbVec3d_swigregister, METH_O, NULL},
	 { "SbVec3d_swiginit", SbVec3d_swiginit, METH_VARARGS, NULL},
	 { "new_SbDPViewVolume", _wrap_new_SbDPViewVolume, METH_NOARGS, "new_SbDPViewVolume() -> SbDPViewVolume"},
	 { "delete_SbDPViewVolume", _wrap_delete_SbDPViewVolume, METH_O, "delete_SbDPViewVolume(SbDPViewVolume self)"},
	 { "SbDPViewVolume_getMatrices", _wrap_SbDPViewVolume_getMatrices, METH_VARARGS, "SbDPViewVolume_getMatrices(SbDPViewVolume self, SbDPMatrix affine, SbDPMatrix proj)"},
	 { "SbDPViewVolume_getMatrix", _wrap_SbDPViewVolume_getMatrix, METH_O, "SbDPViewVolume_getMatrix(SbDPViewVolume self) -> SbDPMatrix"},
	 { "SbDPViewVolume_getCameraSpaceMatrix", _wrap_SbDPViewVolume_getCameraSpaceMatrix, METH_O, "SbDPViewVolume_getCameraSpaceMatrix(SbDPViewVolume self) -> SbDPMatrix"},
	 { "SbDPViewVolume_projectPointToLine", _wrap_SbDPViewVolume_projectPointToLine, METH_VARARGS, "\n"
		"SbDPViewVolume_projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbDPLine line)\n"
		"SbDPViewVolume_projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbVec3d line0, SbVec3d line1)\n"
		""},
	 { "SbDPViewVolume_projectToScreen", _wrap_SbDPViewVolume_projectToScreen, METH_VARARGS, "SbDPViewVolume_projectToScreen(SbDPViewVolume self, SbVec3d src, SbVec3d dst)"},
	 { "SbDPViewVolume_getPlane", _wrap_SbDPViewVolume_getPlane, METH_VARARGS, "SbDPViewVolume_getPlane(SbDPViewVolume self, double const distFromEye) -> SbPlane"},
	 { "SbDPViewVolume_getSightPoint", _wrap_SbDPViewVolume_getSightPoint, METH_VARARGS, "SbDPViewVolume_getSightPoint(SbDPViewVolume self, double const distFromEye) -> SbVec3d"},
	 { "SbDPViewVolume_getPlanePoint", _wrap_SbDPViewVolume_getPlanePoint, METH_VARARGS, "SbDPViewVolume_getPlanePoint(SbDPViewVolume self, double const distFromEye, SbVec2d normPoint) -> SbVec3d"},
	 { "SbDPViewVolume_getAlignRotation", _wrap_SbDPViewVolume_getAlignRotation, METH_VARARGS, "SbDPViewVolume_getAlignRotation(SbDPViewVolume self, SbBool rightAngleOnly=0) -> SbDPRotation"},
	 { "SbDPViewVolume_getWorldToScreenScale", _wrap_SbDPViewVolume_getWorldToScreenScale, METH_VARARGS, "SbDPViewVolume_getWorldToScreenScale(SbDPViewVolume self, SbVec3d worldCenter, double normRadius) -> double"},
	 { "SbDPViewVolume_projectBox", _wrap_SbDPViewVolume_projectBox, METH_VARARGS, "SbDPViewVolume_projectBox(SbDPViewVolume self, SbBox3f box) -> SbVec2d"},
	 { "SbDPViewVolume_narrow", _wrap_SbDPViewVolume_narrow, METH_VARARGS, "\n"
		"SbDPViewVolume_narrow(SbDPViewVolume self, double left, double bottom, double right, double top) -> SbDPViewVolume\n"
		"SbDPViewVolume_narrow(SbDPViewVolume self, SbBox3f box) -> SbDPViewVolume\n"
		""},
	 { "SbDPViewVolume_ortho", _wrap_SbDPViewVolume_ortho, METH_VARARGS, "SbDPViewVolume_ortho(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"},
	 { "SbDPViewVolume_perspective", _wrap_SbDPViewVolume_perspective, METH_VARARGS, "SbDPViewVolume_perspective(SbDPViewVolume self, double fovy, double aspect, double nearval, double farval)"},
	 { "SbDPViewVolume_frustum", _wrap_SbDPViewVolume_frustum, METH_VARARGS, "SbDPViewVolume_frustum(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"},
	 { "SbDPViewVolume_rotateCamera", _wrap_SbDPViewVolume_rotateCamera, METH_VARARGS, "SbDPViewVolume_rotateCamera(SbDPViewVolume self, SbDPRotation q)"},
	 { "SbDPViewVolume_translateCamera", _wrap_SbDPViewVolume_translateCamera, METH_VARARGS, "SbDPViewVolume_translateCamera(SbDPViewVolume self, SbVec3d v)"},
	 { "SbDPViewVolume_zVector", _wrap_SbDPViewVolume_zVector, METH_O, "SbDPViewVolume_zVector(SbDPViewVolume self) -> SbVec3d"},
	 { "SbDPViewVolume_zNarrow", _wrap_SbDPViewVolume_zNarrow, METH_VARARGS, "SbDPViewVolume_zNarrow(SbDPViewVolume self, double nearval, double farval) -> SbDPViewVolume"},
	 { "SbDPViewVolume_scale", _wrap_SbDPViewVolume_scale, METH_VARARGS, "SbDPViewVolume_scale(SbDPViewVolume self, double factor)"},
	 { "SbDPViewVolume_scaleWidth", _wrap_SbDPViewVolume_scaleWidth, METH_VARARGS, "SbDPViewVolume_scaleWidth(SbDPViewVolume self, double ratio)"},
	 { "SbDPViewVolume_scaleHeight", _wrap_SbDPViewVolume_scaleHeight, METH_VARARGS, "SbDPViewVolume_scaleHeight(SbDPViewVolume self, double ratio)"},
	 { "SbDPViewVolume_getProjectionType", _wrap_SbDPViewVolume_getProjectionType, METH_O, "SbDPViewVolume_getProjectionType(SbDPViewVolume self) -> SbDPViewVolume::ProjectionType"},
	 { "SbDPViewVolume_getProjectionPoint", _wrap_SbDPViewVolume_getProjectionPoint, METH_O, "SbDPViewVolume_getProjectionPoint(SbDPViewVolume self) -> SbVec3d"},
	 { "SbDPViewVolume_getProjectionDirection", _wrap_SbDPViewVolume_getProjectionDirection, METH_O, "SbDPViewVolume_getProjectionDirection(SbDPViewVolume self) -> SbVec3d"},
	 { "SbDPViewVolume_getNearDist", _wrap_SbDPViewVolume_getNearDist, METH_O, "SbDPViewVolume_getNearDist(SbDPViewVolume self) -> double"},
	 { "SbDPViewVolume_getWidth", _wrap_SbDPViewVolume_getWidth, METH_O, "SbDPViewVolume_getWidth(SbDPViewVolume self) -> double"},
	 { "SbDPViewVolume_getHeight", _wrap_SbDPViewVolume_getHeight, METH_O, "SbDPViewVolume_getHeight(SbDPViewVolume self) -> double"},
	 { "SbDPViewVolume_getDepth", _wrap_SbDPViewVolume_getDepth, METH_O, "SbDPViewVolume_getDepth(SbDPViewVolume self) -> double"},
	 { "SbDPViewVolume_output", _wrap_SbDPViewVolume_output, METH_VARARGS, "SbDPViewVolume_output(SbDPViewVolume self, FILE * fp)"},
	 { "SbDPViewVolume_getViewVolumePlanes", _wrap_SbDPViewVolume_getViewVolumePlanes, METH_VARARGS, "SbDPViewVolume_getViewVolumePlanes(SbDPViewVolume self, SbPlane planes)"},
	 { "SbDPViewVolume_transform", _wrap_SbDPViewVolume_transform, METH_VARARGS, "SbDPViewVolume_transform(SbDPViewVolume self, SbDPMatrix matrix)"},
	 { "SbDPViewVolume_getViewUp", _wrap_SbDPViewVolume_getViewUp, METH_O, "SbDPViewVolume_getViewUp(SbDPViewVolume self) -> SbVec3d"},
	 { "SbDPViewVolume_copyValues", _wrap_SbDPViewVolume_copyValues, METH_VARARGS, "SbDPViewVolume_copyValues(SbDPViewVolume self, SbViewVolume vv)"},
	 { "SbDPViewVolume_swigregister", SbDPViewVolume_swigregister, METH_O, NULL},
	 { "SbDPViewVolume_swiginit", SbDPViewVolume_swiginit, METH_VARARGS, NULL},
	 { "new_SbViewVolume", _wrap_new_SbViewVolume, METH_NOARGS, "new_SbViewVolume() -> SbViewVolume"},
	 { "delete_SbViewVolume", _wrap_delete_SbViewVolume, METH_O, "delete_SbViewVolume(SbViewVolume self)"},
	 { "SbViewVolume_getMatrices", _wrap_SbViewVolume_getMatrices, METH_VARARGS, "SbViewVolume_getMatrices(SbViewVolume self, SbMatrix affine, SbMatrix proj)"},
	 { "SbViewVolume_getMatrix", _wrap_SbViewVolume_getMatrix, METH_O, "SbViewVolume_getMatrix(SbViewVolume self) -> SbMatrix"},
	 { "SbViewVolume_getCameraSpaceMatrix", _wrap_SbViewVolume_getCameraSpaceMatrix, METH_O, "SbViewVolume_getCameraSpaceMatrix(SbViewVolume self) -> SbMatrix"},
	 { "SbViewVolume_getPlane", _wrap_SbViewVolume_getPlane, METH_VARARGS, "SbViewVolume_getPlane(SbViewVolume self, float const distFromEye) -> SbPlane"},
	 { "SbViewVolume_getSightPoint", _wrap_SbViewVolume_getSightPoint, METH_VARARGS, "SbViewVolume_getSightPoint(SbViewVolume self, float const distFromEye) -> SbVec3f"},
	 { "SbViewVolume_getPlanePoint", _wrap_SbViewVolume_getPlanePoint, METH_VARARGS, "SbViewVolume_getPlanePoint(SbViewVolume self, float const distFromEye, SbVec2f normPoint) -> SbVec3f"},
	 { "SbViewVolume_getAlignRotation", _wrap_SbViewVolume_getAlignRotation, METH_VARARGS, "SbViewVolume_getAlignRotation(SbViewVolume self, SbBool rightAngleOnly=0) -> SbRotation"},
	 { "SbViewVolume_getWorldToScreenScale", _wrap_SbViewVolume_getWorldToScreenScale, METH_VARARGS, "SbViewVolume_getWorldToScreenScale(SbViewVolume self, SbVec3f worldCenter, float normRadius) -> float"},
	 { "SbViewVolume_projectBox", _wrap_SbViewVolume_projectBox, METH_VARARGS, "SbViewVolume_projectBox(SbViewVolume self, SbBox3f box) -> SbVec2f"},
	 { "SbViewVolume_narrow", _wrap_SbViewVolume_narrow, METH_VARARGS, "\n"
		"SbViewVolume_narrow(SbViewVolume self, float left, float bottom, float right, float top) -> SbViewVolume\n"
		"SbViewVolume_narrow(SbViewVolume self, SbBox3f box) -> SbViewVolume\n"
		""},
	 { "SbViewVolume_ortho", _wrap_SbViewVolume_ortho, METH_VARARGS, "SbViewVolume_ortho(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"},
	 { "SbViewVolume_perspective", _wrap_SbViewVolume_perspective, METH_VARARGS, "SbViewVolume_perspective(SbViewVolume self, float fovy, float aspect, float nearval, float farval)"},
	 { "SbViewVolume_frustum", _wrap_SbViewVolume_frustum, METH_VARARGS, "SbViewVolume_frustum(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"},
	 { "SbViewVolume_rotateCamera", _wrap_SbViewVolume_rotateCamera, METH_VARARGS, "SbViewVolume_rotateCamera(SbViewVolume self, SbRotation q)"},
	 { "SbViewVolume_translateCamera", _wrap_SbViewVolume_translateCamera, METH_VARARGS, "SbViewVolume_translateCamera(SbViewVolume self, SbVec3f v)"},
	 { "SbViewVolume_zVector", _wrap_SbViewVolume_zVector, METH_O, "SbViewVolume_zVector(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_zNarrow", _wrap_SbViewVolume_zNarrow, METH_VARARGS, "SbViewVolume_zNarrow(SbViewVolume self, float nearval, float farval) -> SbViewVolume"},
	 { "SbViewVolume_scale", _wrap_SbViewVolume_scale, METH_VARARGS, "SbViewVolume_scale(SbViewVolume self, float factor)"},
	 { "SbViewVolume_scaleWidth", _wrap_SbViewVolume_scaleWidth, METH_VARARGS, "SbViewVolume_scaleWidth(SbViewVolume self, float ratio)"},
	 { "SbViewVolume_scaleHeight", _wrap_SbViewVolume_scaleHeight, METH_VARARGS, "SbViewVolume_scaleHeight(SbViewVolume self, float ratio)"},
	 { "SbViewVolume_getProjectionType", _wrap_SbViewVolume_getProjectionType, METH_O, "SbViewVolume_getProjectionType(SbViewVolume self) -> SbViewVolume::ProjectionType"},
	 { "SbViewVolume_getProjectionPoint", _wrap_SbViewVolume_getProjectionPoint, METH_O, "SbViewVolume_getProjectionPoint(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_getProjectionDirection", _wrap_SbViewVolume_getProjectionDirection, METH_O, "SbViewVolume_getProjectionDirection(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_getNearDist", _wrap_SbViewVolume_getNearDist, METH_O, "SbViewVolume_getNearDist(SbViewVolume self) -> float"},
	 { "SbViewVolume_getWidth", _wrap_SbViewVolume_getWidth, METH_O, "SbViewVolume_getWidth(SbViewVolume self) -> float"},
	 { "SbViewVolume_getHeight", _wrap_SbViewVolume_getHeight, METH_O, "SbViewVolume_getHeight(SbViewVolume self) -> float"},
	 { "SbViewVolume_getDepth", _wrap_SbViewVolume_getDepth, METH_O, "SbViewVolume_getDepth(SbViewVolume self) -> float"},
	 { "SbViewVolume_output", _wrap_SbViewVolume_output, METH_VARARGS, "SbViewVolume_output(SbViewVolume self, FILE * fp)"},
	 { "SbViewVolume_getViewVolumePlanes", _wrap_SbViewVolume_getViewVolumePlanes, METH_VARARGS, "SbViewVolume_getViewVolumePlanes(SbViewVolume self, SbPlane planes)"},
	 { "SbViewVolume_transform", _wrap_SbViewVolume_transform, METH_O, "SbViewVolume_transform(SbViewVolume self)"},
	 { "SbViewVolume_getViewUp", _wrap_SbViewVolume_getViewUp, METH_O, "SbViewVolume_getViewUp(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_intersect", _wrap_SbViewVolume_intersect, METH_VARARGS, "\n"
		"SbViewVolume_intersect(SbViewVolume self, SbVec3f p) -> SbBool\n"
		"SbViewVolume_intersect(SbViewVolume self, SbVec3f p0, SbVec3f p1, SbVec3f closestpoint) -> SbBool\n"
		"SbViewVolume_intersect(SbViewVolume self, SbBox3f box) -> SbBool\n"
		""},
	 { "SbViewVolume_intersectionBox", _wrap_SbViewVolume_intersectionBox, METH_VARARGS, "SbViewVolume_intersectionBox(SbViewVolume self, SbBox3f box) -> SbBox3f"},
	 { "SbViewVolume_outsideTest", _wrap_SbViewVolume_outsideTest, METH_VARARGS, "SbViewVolume_outsideTest(SbViewVolume self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"},
	 { "SbViewVolume_getDPViewVolume", _wrap_SbViewVolume_getDPViewVolume, METH_O, "SbViewVolume_getDPViewVolume(SbViewVolume self) -> SbDPViewVolume"},
	 { "SbViewVolume_type_set", _wrap_SbViewVolume_type_set, METH_VARARGS, "SbViewVolume_type_set(SbViewVolume self, SbViewVolume::ProjectionType type)"},
	 { "SbViewVolume_type_get", _wrap_SbViewVolume_type_get, METH_O, "SbViewVolume_type_get(SbViewVolume self) -> SbViewVolume::ProjectionType"},
	 { "SbViewVolume_projPoint_set", _wrap_SbViewVolume_projPoint_set, METH_VARARGS, "SbViewVolume_projPoint_set(SbViewVolume self, SbVec3f projPoint)"},
	 { "SbViewVolume_projPoint_get", _wrap_SbViewVolume_projPoint_get, METH_O, "SbViewVolume_projPoint_get(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_projDir_set", _wrap_SbViewVolume_projDir_set, METH_VARARGS, "SbViewVolume_projDir_set(SbViewVolume self, SbVec3f projDir)"},
	 { "SbViewVolume_projDir_get", _wrap_SbViewVolume_projDir_get, METH_O, "SbViewVolume_projDir_get(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_nearDist_set", _wrap_SbViewVolume_nearDist_set, METH_VARARGS, "SbViewVolume_nearDist_set(SbViewVolume self, float nearDist)"},
	 { "SbViewVolume_nearDist_get", _wrap_SbViewVolume_nearDist_get, METH_O, "SbViewVolume_nearDist_get(SbViewVolume self) -> float"},
	 { "SbViewVolume_nearToFar_set", _wrap_SbViewVolume_nearToFar_set, METH_VARARGS, "SbViewVolume_nearToFar_set(SbViewVolume self, float nearToFar)"},
	 { "SbViewVolume_nearToFar_get", _wrap_SbViewVolume_nearToFar_get, METH_O, "SbViewVolume_nearToFar_get(SbViewVolume self) -> float"},
	 { "SbViewVolume_llf_set", _wrap_SbViewVolume_llf_set, METH_VARARGS, "SbViewVolume_llf_set(SbViewVolume self, SbVec3f llf)"},
	 { "SbViewVolume_llf_get", _wrap_SbViewVolume_llf_get, METH_O, "SbViewVolume_llf_get(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_lrf_set", _wrap_SbViewVolume_lrf_set, METH_VARARGS, "SbViewVolume_lrf_set(SbViewVolume self, SbVec3f lrf)"},
	 { "SbViewVolume_lrf_get", _wrap_SbViewVolume_lrf_get, METH_O, "SbViewVolume_lrf_get(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_ulf_set", _wrap_SbViewVolume_ulf_set, METH_VARARGS, "SbViewVolume_ulf_set(SbViewVolume self, SbVec3f ulf)"},
	 { "SbViewVolume_ulf_get", _wrap_SbViewVolume_ulf_get, METH_O, "SbViewVolume_ulf_get(SbViewVolume self) -> SbVec3f"},
	 { "SbViewVolume_projectPointToLine", _wrap_SbViewVolume_projectPointToLine, METH_VARARGS, "projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"},
	 { "SbViewVolume_projectToScreen", _wrap_SbViewVolume_projectToScreen, METH_VARARGS, "projectToScreen(SbVec3f) -> SbVec3f"},
	 { "SbViewVolume_swigregister", SbViewVolume_swigregister, METH_O, NULL},
	 { "SbViewVolume_swiginit", SbViewVolume_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec3f", _wrap_new_SoSFVec3f, METH_NOARGS, "new_SoSFVec3f() -> SoSFVec3f"},
	 { "delete_SoSFVec3f", _wrap_delete_SoSFVec3f, METH_O, "delete_SoSFVec3f(SoSFVec3f self)"},
	 { "SoSFVec3f_createInstance", _wrap_SoSFVec3f_createInstance, METH_NOARGS, "SoSFVec3f_createInstance() -> void *"},
	 { "SoSFVec3f_getClassTypeId", _wrap_SoSFVec3f_getClassTypeId, METH_NOARGS, "SoSFVec3f_getClassTypeId() -> SoType"},
	 { "SoSFVec3f_getTypeId", _wrap_SoSFVec3f_getTypeId, METH_O, "SoSFVec3f_getTypeId(SoSFVec3f self) -> SoType"},
	 { "SoSFVec3f_copyFrom", _wrap_SoSFVec3f_copyFrom, METH_VARARGS, "SoSFVec3f_copyFrom(SoSFVec3f self, SoField field)"},
	 { "SoSFVec3f_isSame", _wrap_SoSFVec3f_isSame, METH_VARARGS, "SoSFVec3f_isSame(SoSFVec3f self, SoField field) -> SbBool"},
	 { "SoSFVec3f_getValue", _wrap_SoSFVec3f_getValue, METH_O, "SoSFVec3f_getValue(SoSFVec3f self) -> SbVec3f"},
	 { "SoSFVec3f___eq__", _wrap_SoSFVec3f___eq__, METH_VARARGS, "SoSFVec3f___eq__(SoSFVec3f self, SoSFVec3f field) -> int"},
	 { "SoSFVec3f___ne__", _wrap_SoSFVec3f___ne__, METH_VARARGS, "SoSFVec3f___ne__(SoSFVec3f self, SoSFVec3f field) -> int"},
	 { "SoSFVec3f_initClass", _wrap_SoSFVec3f_initClass, METH_NOARGS, "SoSFVec3f_initClass()"},
	 { "SoSFVec3f_setValue", _wrap_SoSFVec3f_setValue, METH_VARARGS, "\n"
		"SoSFVec3f_setValue(SoSFVec3f self, SbVec3f newvalue)\n"
		"SoSFVec3f_setValue(SoSFVec3f self, float x, float y, float z)\n"
		"SoSFVec3f_setValue(SoSFVec3f self, float const [3] xyz)\n"
		"SoSFVec3f_setValue(SoSFVec3f self, SoSFVec3f other)\n"
		""},
	 { "SoSFVec3f_swigregister", SoSFVec3f_swigregister, METH_O, NULL},
	 { "SoSFVec3f_swiginit", SoSFVec3f_swiginit, METH_VARARGS, NULL},
	 { "SoScale_getClassTypeId", _wrap_SoScale_getClassTypeId, METH_NOARGS, "SoScale_getClassTypeId() -> SoType"},
	 { "SoScale_getTypeId", _wrap_SoScale_getTypeId, METH_O, "SoScale_getTypeId(SoScale self) -> SoType"},
	 { "SoScale_initClass", _wrap_SoScale_initClass, METH_NOARGS, "SoScale_initClass()"},
	 { "new_SoScale", _wrap_new_SoScale, METH_NOARGS, "new_SoScale() -> SoScale"},
	 { "SoScale_scaleFactor_set", _wrap_SoScale_scaleFactor_set, METH_VARARGS, "SoScale_scaleFactor_set(SoScale self, SoSFVec3f scaleFactor)"},
	 { "SoScale_scaleFactor_get", _wrap_SoScale_scaleFactor_get, METH_O, "SoScale_scaleFactor_get(SoScale self) -> SoSFVec3f"},
	 { "SoScale_doAction", _wrap_SoScale_doAction, METH_VARARGS, "SoScale_doAction(SoScale self, SoAction action)"},
	 { "SoScale_callback", _wrap_SoScale_callback, METH_VARARGS, "SoScale_callback(SoScale self, SoCallbackAction action)"},
	 { "SoScale_GLRender", _wrap_SoScale_GLRender, METH_VARARGS, "SoScale_GLRender(SoScale self, SoGLRenderAction action)"},
	 { "SoScale_getBoundingBox", _wrap_SoScale_getBoundingBox, METH_VARARGS, "SoScale_getBoundingBox(SoScale self, SoGetBoundingBoxAction action)"},
	 { "SoScale_getMatrix", _wrap_SoScale_getMatrix, METH_VARARGS, "SoScale_getMatrix(SoScale self, SoGetMatrixAction action)"},
	 { "SoScale_pick", _wrap_SoScale_pick, METH_VARARGS, "SoScale_pick(SoScale self, SoPickAction action)"},
	 { "SoScale_getPrimitiveCount", _wrap_SoScale_getPrimitiveCount, METH_VARARGS, "SoScale_getPrimitiveCount(SoScale self, SoGetPrimitiveCountAction action)"},
	 { "SoScale_swigregister", SoScale_swigregister, METH_O, NULL},
	 { "SoScale_swiginit", SoScale_swiginit, METH_VARARGS, NULL},
	 { "SoDragger_getClassTypeId", _wrap_SoDragger_getClassTypeId, METH_NOARGS, "SoDragger_getClassTypeId() -> SoType"},
	 { "SoDragger_getTypeId", _wrap_SoDragger_getTypeId, METH_O, "SoDragger_getTypeId(SoDragger self) -> SoType"},
	 { "SoDragger_getClassNodekitCatalog", _wrap_SoDragger_getClassNodekitCatalog, METH_NOARGS, "SoDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoDragger_getNodekitCatalog", _wrap_SoDragger_getNodekitCatalog, METH_O, "SoDragger_getNodekitCatalog(SoDragger self) -> SoNodekitCatalog"},
	 { "SoDragger_isActive_set", _wrap_SoDragger_isActive_set, METH_VARARGS, "SoDragger_isActive_set(SoDragger self, SoSFBool isActive)"},
	 { "SoDragger_isActive_get", _wrap_SoDragger_isActive_get, METH_O, "SoDragger_isActive_get(SoDragger self) -> SoSFBool"},
	 { "SoDragger_callback", _wrap_SoDragger_callback, METH_VARARGS, "SoDragger_callback(SoDragger self, SoCallbackAction action)"},
	 { "SoDragger_GLRender", _wrap_SoDragger_GLRender, METH_VARARGS, "SoDragger_GLRender(SoDragger self, SoGLRenderAction action)"},
	 { "SoDragger_getMatrix", _wrap_SoDragger_getMatrix, METH_VARARGS, "SoDragger_getMatrix(SoDragger self, SoGetMatrixAction action)"},
	 { "SoDragger_rayPick", _wrap_SoDragger_rayPick, METH_VARARGS, "SoDragger_rayPick(SoDragger self, SoRayPickAction action)"},
	 { "SoDragger_search", _wrap_SoDragger_search, METH_VARARGS, "SoDragger_search(SoDragger self, SoSearchAction action)"},
	 { "SoDragger_write", _wrap_SoDragger_write, METH_VARARGS, "SoDragger_write(SoDragger self, SoWriteAction action)"},
	 { "SoDragger_getPrimitiveCount", _wrap_SoDragger_getPrimitiveCount, METH_VARARGS, "SoDragger_getPrimitiveCount(SoDragger self, SoGetPrimitiveCountAction action)"},
	 { "SoDragger_setProjectorEpsilon", _wrap_SoDragger_setProjectorEpsilon, METH_VARARGS, "SoDragger_setProjectorEpsilon(SoDragger self, float const epsilon)"},
	 { "SoDragger_getProjectorEpsilon", _wrap_SoDragger_getProjectorEpsilon, METH_O, "SoDragger_getProjectorEpsilon(SoDragger self) -> float"},
	 { "SoDragger_setMinGesture", _wrap_SoDragger_setMinGesture, METH_VARARGS, "SoDragger_setMinGesture(SoDragger self, int pixels)"},
	 { "SoDragger_getMinGesture", _wrap_SoDragger_getMinGesture, METH_O, "SoDragger_getMinGesture(SoDragger self) -> int"},
	 { "SoDragger_enableValueChangedCallbacks", _wrap_SoDragger_enableValueChangedCallbacks, METH_VARARGS, "SoDragger_enableValueChangedCallbacks(SoDragger self, SbBool newval) -> SbBool"},
	 { "SoDragger_getMotionMatrix", _wrap_SoDragger_getMotionMatrix, METH_O, "SoDragger_getMotionMatrix(SoDragger self) -> SbMatrix"},
	 { "SoDragger_registerChildDragger", _wrap_SoDragger_registerChildDragger, METH_VARARGS, "SoDragger_registerChildDragger(SoDragger self, SoDragger child)"},
	 { "SoDragger_unregisterChildDragger", _wrap_SoDragger_unregisterChildDragger, METH_VARARGS, "SoDragger_unregisterChildDragger(SoDragger self, SoDragger child)"},
	 { "SoDragger_registerChildDraggerMovingIndependently", _wrap_SoDragger_registerChildDraggerMovingIndependently, METH_VARARGS, "SoDragger_registerChildDraggerMovingIndependently(SoDragger self, SoDragger child)"},
	 { "SoDragger_unregisterChildDraggerMovingIndependently", _wrap_SoDragger_unregisterChildDraggerMovingIndependently, METH_VARARGS, "SoDragger_unregisterChildDraggerMovingIndependently(SoDragger self, SoDragger child)"},
	 { "SoDragger_getLocalToWorldMatrix", _wrap_SoDragger_getLocalToWorldMatrix, METH_O, "SoDragger_getLocalToWorldMatrix(SoDragger self) -> SbMatrix"},
	 { "SoDragger_getWorldToLocalMatrix", _wrap_SoDragger_getWorldToLocalMatrix, METH_O, "SoDragger_getWorldToLocalMatrix(SoDragger self) -> SbMatrix"},
	 { "SoDragger_getLocalStartingPoint", _wrap_SoDragger_getLocalStartingPoint, METH_O, "SoDragger_getLocalStartingPoint(SoDragger self) -> SbVec3f"},
	 { "SoDragger_getWorldStartingPoint", _wrap_SoDragger_getWorldStartingPoint, METH_O, "SoDragger_getWorldStartingPoint(SoDragger self) -> SbVec3f"},
	 { "SoDragger_getPartToLocalMatrix", _wrap_SoDragger_getPartToLocalMatrix, METH_VARARGS, "SoDragger_getPartToLocalMatrix(SoDragger self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"},
	 { "SoDragger_transformMatrixLocalToWorld", _wrap_SoDragger_transformMatrixLocalToWorld, METH_VARARGS, "SoDragger_transformMatrixLocalToWorld(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"},
	 { "SoDragger_transformMatrixWorldToLocal", _wrap_SoDragger_transformMatrixWorldToLocal, METH_VARARGS, "SoDragger_transformMatrixWorldToLocal(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"},
	 { "SoDragger_transformMatrixToLocalSpace", _wrap_SoDragger_transformMatrixToLocalSpace, METH_VARARGS, "SoDragger_transformMatrixToLocalSpace(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"},
	 { "SoDragger_setMotionMatrix", _wrap_SoDragger_setMotionMatrix, METH_VARARGS, "SoDragger_setMotionMatrix(SoDragger self, SbMatrix newmatrix)"},
	 { "SoDragger_valueChanged", _wrap_SoDragger_valueChanged, METH_O, "SoDragger_valueChanged(SoDragger self)"},
	 { "SoDragger_getStartMotionMatrix", _wrap_SoDragger_getStartMotionMatrix, METH_O, "SoDragger_getStartMotionMatrix(SoDragger self) -> SbMatrix"},
	 { "SoDragger_saveStartParameters", _wrap_SoDragger_saveStartParameters, METH_O, "SoDragger_saveStartParameters(SoDragger self)"},
	 { "SoDragger_getPickPath", _wrap_SoDragger_getPickPath, METH_O, "SoDragger_getPickPath(SoDragger self) -> SoPath"},
	 { "SoDragger_getEvent", _wrap_SoDragger_getEvent, METH_O, "SoDragger_getEvent(SoDragger self) -> SoEvent"},
	 { "SoDragger_createPathToThis", _wrap_SoDragger_createPathToThis, METH_O, "SoDragger_createPathToThis(SoDragger self) -> SoPath"},
	 { "SoDragger_getSurrogatePartPickedOwner", _wrap_SoDragger_getSurrogatePartPickedOwner, METH_O, "SoDragger_getSurrogatePartPickedOwner(SoDragger self) -> SoPath"},
	 { "SoDragger_getSurrogatePartPickedName", _wrap_SoDragger_getSurrogatePartPickedName, METH_O, "SoDragger_getSurrogatePartPickedName(SoDragger self) -> SbName"},
	 { "SoDragger_getSurrogatePartPickedPath", _wrap_SoDragger_getSurrogatePartPickedPath, METH_O, "SoDragger_getSurrogatePartPickedPath(SoDragger self) -> SoPath"},
	 { "SoDragger_setStartingPoint", _wrap_SoDragger_setStartingPoint, METH_VARARGS, "\n"
		"SoDragger_setStartingPoint(SoDragger self, SoPickedPoint newpoint)\n"
		"SoDragger_setStartingPoint(SoDragger self, SbVec3f newpoint)\n"
		""},
	 { "SoDragger_getViewVolume", _wrap_SoDragger_getViewVolume, METH_O, "SoDragger_getViewVolume(SoDragger self) -> SbViewVolume"},
	 { "SoDragger_setViewVolume", _wrap_SoDragger_setViewVolume, METH_VARARGS, "SoDragger_setViewVolume(SoDragger self, SbViewVolume vol)"},
	 { "SoDragger_getViewportRegion", _wrap_SoDragger_getViewportRegion, METH_O, "SoDragger_getViewportRegion(SoDragger self) -> SbViewportRegion"},
	 { "SoDragger_setViewportRegion", _wrap_SoDragger_setViewportRegion, METH_VARARGS, "SoDragger_setViewportRegion(SoDragger self, SbViewportRegion reg)"},
	 { "SoDragger_getHandleEventAction", _wrap_SoDragger_getHandleEventAction, METH_O, "SoDragger_getHandleEventAction(SoDragger self) -> SoHandleEventAction"},
	 { "SoDragger_setHandleEventAction", _wrap_SoDragger_setHandleEventAction, METH_VARARGS, "SoDragger_setHandleEventAction(SoDragger self, SoHandleEventAction newAction)"},
	 { "SoDragger_setTempPathToThis", _wrap_SoDragger_setTempPathToThis, METH_VARARGS, "SoDragger_setTempPathToThis(SoDragger self, SoPath somethingclose)"},
	 { "SoDragger_grabEventsSetup", _wrap_SoDragger_grabEventsSetup, METH_O, "SoDragger_grabEventsSetup(SoDragger self)"},
	 { "SoDragger_grabEventsCleanup", _wrap_SoDragger_grabEventsCleanup, METH_O, "SoDragger_grabEventsCleanup(SoDragger self)"},
	 { "SoDragger_workFieldsIntoTransform", _wrap_SoDragger_workFieldsIntoTransform, METH_VARARGS, "SoDragger_workFieldsIntoTransform(SoDragger self, SbMatrix mtx)"},
	 { "SoDragger_setFrontOnProjector", _wrap_SoDragger_setFrontOnProjector, METH_VARARGS, "SoDragger_setFrontOnProjector(SoDragger self, SoDragger::ProjectorFrontSetting newval)"},
	 { "SoDragger_getFrontOnProjector", _wrap_SoDragger_getFrontOnProjector, METH_O, "SoDragger_getFrontOnProjector(SoDragger self) -> SoDragger::ProjectorFrontSetting"},
	 { "SoDragger_setMinScale", _wrap_SoDragger_setMinScale, METH_O, "SoDragger_setMinScale(float newminscale)"},
	 { "SoDragger_getMinScale", _wrap_SoDragger_getMinScale, METH_NOARGS, "SoDragger_getMinScale() -> float"},
	 { "SoDragger_workValuesIntoTransform", _wrap_SoDragger_workValuesIntoTransform, METH_VARARGS, "SoDragger_workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"},
	 { "SoDragger_getTransformFast", _wrap_SoDragger_getTransformFast, METH_VARARGS, "\n"
		"SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation, SbVec3f center)\n"
		"SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation)\n"
		""},
	 { "SoDragger_appendTranslation", _wrap_SoDragger_appendTranslation, METH_VARARGS, "SoDragger_appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix"},
	 { "SoDragger_appendScale", _wrap_SoDragger_appendScale, METH_VARARGS, "SoDragger_appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix"},
	 { "SoDragger_appendRotation", _wrap_SoDragger_appendRotation, METH_VARARGS, "SoDragger_appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix"},
	 { "SoDragger_initClass", _wrap_SoDragger_initClass, METH_NOARGS, "SoDragger_initClass()"},
	 { "SoDragger_initClasses", _wrap_SoDragger_initClasses, METH_NOARGS, "SoDragger_initClasses()"},
	 { "SoDragger_addStartCallback", _wrap_SoDragger_addStartCallback, METH_VARARGS, "\n"
		"SoDragger_addStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_addStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_removeStartCallback", _wrap_SoDragger_removeStartCallback, METH_VARARGS, "\n"
		"SoDragger_removeStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_removeStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_addMotionCallback", _wrap_SoDragger_addMotionCallback, METH_VARARGS, "\n"
		"SoDragger_addMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_addMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_removeMotionCallback", _wrap_SoDragger_removeMotionCallback, METH_VARARGS, "\n"
		"SoDragger_removeMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_removeMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_addFinishCallback", _wrap_SoDragger_addFinishCallback, METH_VARARGS, "\n"
		"SoDragger_addFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_addFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_removeFinishCallback", _wrap_SoDragger_removeFinishCallback, METH_VARARGS, "\n"
		"SoDragger_removeFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_removeFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_addValueChangedCallback", _wrap_SoDragger_addValueChangedCallback, METH_VARARGS, "\n"
		"SoDragger_addValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_addValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_removeValueChangedCallback", _wrap_SoDragger_removeValueChangedCallback, METH_VARARGS, "\n"
		"SoDragger_removeValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_removeValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_addOtherEventCallback", _wrap_SoDragger_addOtherEventCallback, METH_VARARGS, "\n"
		"SoDragger_addOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_addOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_removeOtherEventCallback", _wrap_SoDragger_removeOtherEventCallback, METH_VARARGS, "\n"
		"SoDragger_removeOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)\n"
		"SoDragger_removeOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)\n"
		""},
	 { "SoDragger_swigregister", SoDragger_swigregister, METH_O, NULL},
	 { "new_SoSFRotation", _wrap_new_SoSFRotation, METH_NOARGS, "new_SoSFRotation() -> SoSFRotation"},
	 { "delete_SoSFRotation", _wrap_delete_SoSFRotation, METH_O, "delete_SoSFRotation(SoSFRotation self)"},
	 { "SoSFRotation_createInstance", _wrap_SoSFRotation_createInstance, METH_NOARGS, "SoSFRotation_createInstance() -> void *"},
	 { "SoSFRotation_getClassTypeId", _wrap_SoSFRotation_getClassTypeId, METH_NOARGS, "SoSFRotation_getClassTypeId() -> SoType"},
	 { "SoSFRotation_getTypeId", _wrap_SoSFRotation_getTypeId, METH_O, "SoSFRotation_getTypeId(SoSFRotation self) -> SoType"},
	 { "SoSFRotation_copyFrom", _wrap_SoSFRotation_copyFrom, METH_VARARGS, "SoSFRotation_copyFrom(SoSFRotation self, SoField field)"},
	 { "SoSFRotation_isSame", _wrap_SoSFRotation_isSame, METH_VARARGS, "SoSFRotation_isSame(SoSFRotation self, SoField field) -> SbBool"},
	 { "SoSFRotation___eq__", _wrap_SoSFRotation___eq__, METH_VARARGS, "SoSFRotation___eq__(SoSFRotation self, SoSFRotation field) -> int"},
	 { "SoSFRotation___ne__", _wrap_SoSFRotation___ne__, METH_VARARGS, "SoSFRotation___ne__(SoSFRotation self, SoSFRotation field) -> int"},
	 { "SoSFRotation_initClass", _wrap_SoSFRotation_initClass, METH_NOARGS, "SoSFRotation_initClass()"},
	 { "SoSFRotation_getValue", _wrap_SoSFRotation_getValue, METH_VARARGS, "\n"
		"SoSFRotation_getValue(SoSFRotation self) -> SbRotation\n"
		"SoSFRotation_getValue(SoSFRotation self, float & angle)\n"
		""},
	 { "SoSFRotation_setValue", _wrap_SoSFRotation_setValue, METH_VARARGS, "\n"
		"SoSFRotation_setValue(SoSFRotation self, SbRotation newvalue)\n"
		"SoSFRotation_setValue(SoSFRotation self, float const q0, float const q1, float const q2, float const q3)\n"
		"SoSFRotation_setValue(SoSFRotation self, float const [4] q)\n"
		"SoSFRotation_setValue(SoSFRotation self, SbVec3f axis, float const angle)\n"
		"SoSFRotation_setValue(SoSFRotation self, SoSFRotation other)\n"
		""},
	 { "SoSFRotation_swigregister", SoSFRotation_swigregister, METH_O, NULL},
	 { "SoSFRotation_swiginit", SoSFRotation_swiginit, METH_VARARGS, NULL},
	 { "SoCenterballDragger_getClassTypeId", _wrap_SoCenterballDragger_getClassTypeId, METH_NOARGS, "SoCenterballDragger_getClassTypeId() -> SoType"},
	 { "SoCenterballDragger_getTypeId", _wrap_SoCenterballDragger_getTypeId, METH_O, "SoCenterballDragger_getTypeId(SoCenterballDragger self) -> SoType"},
	 { "SoCenterballDragger_getClassNodekitCatalog", _wrap_SoCenterballDragger_getClassNodekitCatalog, METH_NOARGS, "SoCenterballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoCenterballDragger_getNodekitCatalog", _wrap_SoCenterballDragger_getNodekitCatalog, METH_O, "SoCenterballDragger_getNodekitCatalog(SoCenterballDragger self) -> SoNodekitCatalog"},
	 { "SoCenterballDragger_initClass", _wrap_SoCenterballDragger_initClass, METH_NOARGS, "SoCenterballDragger_initClass()"},
	 { "new_SoCenterballDragger", _wrap_new_SoCenterballDragger, METH_NOARGS, "new_SoCenterballDragger() -> SoCenterballDragger"},
	 { "SoCenterballDragger_saveStartParameters", _wrap_SoCenterballDragger_saveStartParameters, METH_O, "SoCenterballDragger_saveStartParameters(SoCenterballDragger self)"},
	 { "SoCenterballDragger_rotation_set", _wrap_SoCenterballDragger_rotation_set, METH_VARARGS, "SoCenterballDragger_rotation_set(SoCenterballDragger self, SoSFRotation rotation)"},
	 { "SoCenterballDragger_rotation_get", _wrap_SoCenterballDragger_rotation_get, METH_O, "SoCenterballDragger_rotation_get(SoCenterballDragger self) -> SoSFRotation"},
	 { "SoCenterballDragger_center_set", _wrap_SoCenterballDragger_center_set, METH_VARARGS, "SoCenterballDragger_center_set(SoCenterballDragger self, SoSFVec3f center)"},
	 { "SoCenterballDragger_center_get", _wrap_SoCenterballDragger_center_get, METH_O, "SoCenterballDragger_center_get(SoCenterballDragger self) -> SoSFVec3f"},
	 { "SoCenterballDragger_swigregister", SoCenterballDragger_swigregister, METH_O, NULL},
	 { "SoCenterballDragger_swiginit", SoCenterballDragger_swiginit, METH_VARARGS, NULL},
	 { "SoDirectionalLightDragger_getClassTypeId", _wrap_SoDirectionalLightDragger_getClassTypeId, METH_NOARGS, "SoDirectionalLightDragger_getClassTypeId() -> SoType"},
	 { "SoDirectionalLightDragger_getTypeId", _wrap_SoDirectionalLightDragger_getTypeId, METH_O, "SoDirectionalLightDragger_getTypeId(SoDirectionalLightDragger self) -> SoType"},
	 { "SoDirectionalLightDragger_getClassNodekitCatalog", _wrap_SoDirectionalLightDragger_getClassNodekitCatalog, METH_NOARGS, "SoDirectionalLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoDirectionalLightDragger_getNodekitCatalog", _wrap_SoDirectionalLightDragger_getNodekitCatalog, METH_O, "SoDirectionalLightDragger_getNodekitCatalog(SoDirectionalLightDragger self) -> SoNodekitCatalog"},
	 { "SoDirectionalLightDragger_initClass", _wrap_SoDirectionalLightDragger_initClass, METH_NOARGS, "SoDirectionalLightDragger_initClass()"},
	 { "new_SoDirectionalLightDragger", _wrap_new_SoDirectionalLightDragger, METH_NOARGS, "new_SoDirectionalLightDragger() -> SoDirectionalLightDragger"},
	 { "SoDirectionalLightDragger_rotation_set", _wrap_SoDirectionalLightDragger_rotation_set, METH_VARARGS, "SoDirectionalLightDragger_rotation_set(SoDirectionalLightDragger self, SoSFRotation rotation)"},
	 { "SoDirectionalLightDragger_rotation_get", _wrap_SoDirectionalLightDragger_rotation_get, METH_O, "SoDirectionalLightDragger_rotation_get(SoDirectionalLightDragger self) -> SoSFRotation"},
	 { "SoDirectionalLightDragger_translation_set", _wrap_SoDirectionalLightDragger_translation_set, METH_VARARGS, "SoDirectionalLightDragger_translation_set(SoDirectionalLightDragger self, SoSFVec3f translation)"},
	 { "SoDirectionalLightDragger_translation_get", _wrap_SoDirectionalLightDragger_translation_get, METH_O, "SoDirectionalLightDragger_translation_get(SoDirectionalLightDragger self) -> SoSFVec3f"},
	 { "SoDirectionalLightDragger_swigregister", SoDirectionalLightDragger_swigregister, METH_O, NULL},
	 { "SoDirectionalLightDragger_swiginit", SoDirectionalLightDragger_swiginit, METH_VARARGS, NULL},
	 { "SoDragPointDragger_getClassTypeId", _wrap_SoDragPointDragger_getClassTypeId, METH_NOARGS, "SoDragPointDragger_getClassTypeId() -> SoType"},
	 { "SoDragPointDragger_getTypeId", _wrap_SoDragPointDragger_getTypeId, METH_O, "SoDragPointDragger_getTypeId(SoDragPointDragger self) -> SoType"},
	 { "SoDragPointDragger_getClassNodekitCatalog", _wrap_SoDragPointDragger_getClassNodekitCatalog, METH_NOARGS, "SoDragPointDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoDragPointDragger_getNodekitCatalog", _wrap_SoDragPointDragger_getNodekitCatalog, METH_O, "SoDragPointDragger_getNodekitCatalog(SoDragPointDragger self) -> SoNodekitCatalog"},
	 { "SoDragPointDragger_initClass", _wrap_SoDragPointDragger_initClass, METH_NOARGS, "SoDragPointDragger_initClass()"},
	 { "new_SoDragPointDragger", _wrap_new_SoDragPointDragger, METH_NOARGS, "new_SoDragPointDragger() -> SoDragPointDragger"},
	 { "SoDragPointDragger_translation_set", _wrap_SoDragPointDragger_translation_set, METH_VARARGS, "SoDragPointDragger_translation_set(SoDragPointDragger self, SoSFVec3f translation)"},
	 { "SoDragPointDragger_translation_get", _wrap_SoDragPointDragger_translation_get, METH_O, "SoDragPointDragger_translation_get(SoDragPointDragger self) -> SoSFVec3f"},
	 { "SoDragPointDragger_setJumpLimit", _wrap_SoDragPointDragger_setJumpLimit, METH_VARARGS, "SoDragPointDragger_setJumpLimit(SoDragPointDragger self, float const limit)"},
	 { "SoDragPointDragger_getJumpLimit", _wrap_SoDragPointDragger_getJumpLimit, METH_O, "SoDragPointDragger_getJumpLimit(SoDragPointDragger self) -> float"},
	 { "SoDragPointDragger_showNextDraggerSet", _wrap_SoDragPointDragger_showNextDraggerSet, METH_O, "SoDragPointDragger_showNextDraggerSet(SoDragPointDragger self)"},
	 { "SoDragPointDragger_swigregister", SoDragPointDragger_swigregister, METH_O, NULL},
	 { "SoDragPointDragger_swiginit", SoDragPointDragger_swiginit, METH_VARARGS, NULL},
	 { "SoHandleBoxDragger_getClassTypeId", _wrap_SoHandleBoxDragger_getClassTypeId, METH_NOARGS, "SoHandleBoxDragger_getClassTypeId() -> SoType"},
	 { "SoHandleBoxDragger_getTypeId", _wrap_SoHandleBoxDragger_getTypeId, METH_O, "SoHandleBoxDragger_getTypeId(SoHandleBoxDragger self) -> SoType"},
	 { "SoHandleBoxDragger_getClassNodekitCatalog", _wrap_SoHandleBoxDragger_getClassNodekitCatalog, METH_NOARGS, "SoHandleBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoHandleBoxDragger_getNodekitCatalog", _wrap_SoHandleBoxDragger_getNodekitCatalog, METH_O, "SoHandleBoxDragger_getNodekitCatalog(SoHandleBoxDragger self) -> SoNodekitCatalog"},
	 { "SoHandleBoxDragger_initClass", _wrap_SoHandleBoxDragger_initClass, METH_NOARGS, "SoHandleBoxDragger_initClass()"},
	 { "new_SoHandleBoxDragger", _wrap_new_SoHandleBoxDragger, METH_NOARGS, "new_SoHandleBoxDragger() -> SoHandleBoxDragger"},
	 { "SoHandleBoxDragger_scaleFactor_set", _wrap_SoHandleBoxDragger_scaleFactor_set, METH_VARARGS, "SoHandleBoxDragger_scaleFactor_set(SoHandleBoxDragger self, SoSFVec3f scaleFactor)"},
	 { "SoHandleBoxDragger_scaleFactor_get", _wrap_SoHandleBoxDragger_scaleFactor_get, METH_O, "SoHandleBoxDragger_scaleFactor_get(SoHandleBoxDragger self) -> SoSFVec3f"},
	 { "SoHandleBoxDragger_translation_set", _wrap_SoHandleBoxDragger_translation_set, METH_VARARGS, "SoHandleBoxDragger_translation_set(SoHandleBoxDragger self, SoSFVec3f translation)"},
	 { "SoHandleBoxDragger_translation_get", _wrap_SoHandleBoxDragger_translation_get, METH_O, "SoHandleBoxDragger_translation_get(SoHandleBoxDragger self) -> SoSFVec3f"},
	 { "SoHandleBoxDragger_swigregister", SoHandleBoxDragger_swigregister, METH_O, NULL},
	 { "SoHandleBoxDragger_swiginit", SoHandleBoxDragger_swiginit, METH_VARARGS, NULL},
	 { "SoJackDragger_getClassTypeId", _wrap_SoJackDragger_getClassTypeId, METH_NOARGS, "SoJackDragger_getClassTypeId() -> SoType"},
	 { "SoJackDragger_getTypeId", _wrap_SoJackDragger_getTypeId, METH_O, "SoJackDragger_getTypeId(SoJackDragger self) -> SoType"},
	 { "SoJackDragger_getClassNodekitCatalog", _wrap_SoJackDragger_getClassNodekitCatalog, METH_NOARGS, "SoJackDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoJackDragger_getNodekitCatalog", _wrap_SoJackDragger_getNodekitCatalog, METH_O, "SoJackDragger_getNodekitCatalog(SoJackDragger self) -> SoNodekitCatalog"},
	 { "SoJackDragger_initClass", _wrap_SoJackDragger_initClass, METH_NOARGS, "SoJackDragger_initClass()"},
	 { "new_SoJackDragger", _wrap_new_SoJackDragger, METH_NOARGS, "new_SoJackDragger() -> SoJackDragger"},
	 { "SoJackDragger_rotation_set", _wrap_SoJackDragger_rotation_set, METH_VARARGS, "SoJackDragger_rotation_set(SoJackDragger self, SoSFRotation rotation)"},
	 { "SoJackDragger_rotation_get", _wrap_SoJackDragger_rotation_get, METH_O, "SoJackDragger_rotation_get(SoJackDragger self) -> SoSFRotation"},
	 { "SoJackDragger_translation_set", _wrap_SoJackDragger_translation_set, METH_VARARGS, "SoJackDragger_translation_set(SoJackDragger self, SoSFVec3f translation)"},
	 { "SoJackDragger_translation_get", _wrap_SoJackDragger_translation_get, METH_O, "SoJackDragger_translation_get(SoJackDragger self) -> SoSFVec3f"},
	 { "SoJackDragger_scaleFactor_set", _wrap_SoJackDragger_scaleFactor_set, METH_VARARGS, "SoJackDragger_scaleFactor_set(SoJackDragger self, SoSFVec3f scaleFactor)"},
	 { "SoJackDragger_scaleFactor_get", _wrap_SoJackDragger_scaleFactor_get, METH_O, "SoJackDragger_scaleFactor_get(SoJackDragger self) -> SoSFVec3f"},
	 { "SoJackDragger_swigregister", SoJackDragger_swigregister, METH_O, NULL},
	 { "SoJackDragger_swiginit", SoJackDragger_swiginit, METH_VARARGS, NULL},
	 { "SoPointLightDragger_getClassTypeId", _wrap_SoPointLightDragger_getClassTypeId, METH_NOARGS, "SoPointLightDragger_getClassTypeId() -> SoType"},
	 { "SoPointLightDragger_getTypeId", _wrap_SoPointLightDragger_getTypeId, METH_O, "SoPointLightDragger_getTypeId(SoPointLightDragger self) -> SoType"},
	 { "SoPointLightDragger_getClassNodekitCatalog", _wrap_SoPointLightDragger_getClassNodekitCatalog, METH_NOARGS, "SoPointLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoPointLightDragger_getNodekitCatalog", _wrap_SoPointLightDragger_getNodekitCatalog, METH_O, "SoPointLightDragger_getNodekitCatalog(SoPointLightDragger self) -> SoNodekitCatalog"},
	 { "SoPointLightDragger_initClass", _wrap_SoPointLightDragger_initClass, METH_NOARGS, "SoPointLightDragger_initClass()"},
	 { "new_SoPointLightDragger", _wrap_new_SoPointLightDragger, METH_NOARGS, "new_SoPointLightDragger() -> SoPointLightDragger"},
	 { "SoPointLightDragger_translation_set", _wrap_SoPointLightDragger_translation_set, METH_VARARGS, "SoPointLightDragger_translation_set(SoPointLightDragger self, SoSFVec3f translation)"},
	 { "SoPointLightDragger_translation_get", _wrap_SoPointLightDragger_translation_get, METH_O, "SoPointLightDragger_translation_get(SoPointLightDragger self) -> SoSFVec3f"},
	 { "SoPointLightDragger_swigregister", SoPointLightDragger_swigregister, METH_O, NULL},
	 { "SoPointLightDragger_swiginit", SoPointLightDragger_swiginit, METH_VARARGS, NULL},
	 { "SoRotateCylindricalDragger_getClassTypeId", _wrap_SoRotateCylindricalDragger_getClassTypeId, METH_NOARGS, "SoRotateCylindricalDragger_getClassTypeId() -> SoType"},
	 { "SoRotateCylindricalDragger_getTypeId", _wrap_SoRotateCylindricalDragger_getTypeId, METH_O, "SoRotateCylindricalDragger_getTypeId(SoRotateCylindricalDragger self) -> SoType"},
	 { "SoRotateCylindricalDragger_getClassNodekitCatalog", _wrap_SoRotateCylindricalDragger_getClassNodekitCatalog, METH_NOARGS, "SoRotateCylindricalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoRotateCylindricalDragger_getNodekitCatalog", _wrap_SoRotateCylindricalDragger_getNodekitCatalog, METH_O, "SoRotateCylindricalDragger_getNodekitCatalog(SoRotateCylindricalDragger self) -> SoNodekitCatalog"},
	 { "SoRotateCylindricalDragger_initClass", _wrap_SoRotateCylindricalDragger_initClass, METH_NOARGS, "SoRotateCylindricalDragger_initClass()"},
	 { "new_SoRotateCylindricalDragger", _wrap_new_SoRotateCylindricalDragger, METH_NOARGS, "new_SoRotateCylindricalDragger() -> SoRotateCylindricalDragger"},
	 { "SoRotateCylindricalDragger_rotation_set", _wrap_SoRotateCylindricalDragger_rotation_set, METH_VARARGS, "SoRotateCylindricalDragger_rotation_set(SoRotateCylindricalDragger self, SoSFRotation rotation)"},
	 { "SoRotateCylindricalDragger_rotation_get", _wrap_SoRotateCylindricalDragger_rotation_get, METH_O, "SoRotateCylindricalDragger_rotation_get(SoRotateCylindricalDragger self) -> SoSFRotation"},
	 { "SoRotateCylindricalDragger_setProjector", _wrap_SoRotateCylindricalDragger_setProjector, METH_VARARGS, "SoRotateCylindricalDragger_setProjector(SoRotateCylindricalDragger self, SbCylinderProjector p)"},
	 { "SoRotateCylindricalDragger_getProjector", _wrap_SoRotateCylindricalDragger_getProjector, METH_O, "SoRotateCylindricalDragger_getProjector(SoRotateCylindricalDragger self) -> SbCylinderProjector"},
	 { "SoRotateCylindricalDragger_swigregister", SoRotateCylindricalDragger_swigregister, METH_O, NULL},
	 { "SoRotateCylindricalDragger_swiginit", SoRotateCylindricalDragger_swiginit, METH_VARARGS, NULL},
	 { "SoRotateDiscDragger_getClassTypeId", _wrap_SoRotateDiscDragger_getClassTypeId, METH_NOARGS, "SoRotateDiscDragger_getClassTypeId() -> SoType"},
	 { "SoRotateDiscDragger_getTypeId", _wrap_SoRotateDiscDragger_getTypeId, METH_O, "SoRotateDiscDragger_getTypeId(SoRotateDiscDragger self) -> SoType"},
	 { "SoRotateDiscDragger_getClassNodekitCatalog", _wrap_SoRotateDiscDragger_getClassNodekitCatalog, METH_NOARGS, "SoRotateDiscDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoRotateDiscDragger_getNodekitCatalog", _wrap_SoRotateDiscDragger_getNodekitCatalog, METH_O, "SoRotateDiscDragger_getNodekitCatalog(SoRotateDiscDragger self) -> SoNodekitCatalog"},
	 { "SoRotateDiscDragger_initClass", _wrap_SoRotateDiscDragger_initClass, METH_NOARGS, "SoRotateDiscDragger_initClass()"},
	 { "new_SoRotateDiscDragger", _wrap_new_SoRotateDiscDragger, METH_NOARGS, "new_SoRotateDiscDragger() -> SoRotateDiscDragger"},
	 { "SoRotateDiscDragger_rotation_set", _wrap_SoRotateDiscDragger_rotation_set, METH_VARARGS, "SoRotateDiscDragger_rotation_set(SoRotateDiscDragger self, SoSFRotation rotation)"},
	 { "SoRotateDiscDragger_rotation_get", _wrap_SoRotateDiscDragger_rotation_get, METH_O, "SoRotateDiscDragger_rotation_get(SoRotateDiscDragger self) -> SoSFRotation"},
	 { "SoRotateDiscDragger_swigregister", SoRotateDiscDragger_swigregister, METH_O, NULL},
	 { "SoRotateDiscDragger_swiginit", SoRotateDiscDragger_swiginit, METH_VARARGS, NULL},
	 { "SoRotateSphericalDragger_getClassTypeId", _wrap_SoRotateSphericalDragger_getClassTypeId, METH_NOARGS, "SoRotateSphericalDragger_getClassTypeId() -> SoType"},
	 { "SoRotateSphericalDragger_getTypeId", _wrap_SoRotateSphericalDragger_getTypeId, METH_O, "SoRotateSphericalDragger_getTypeId(SoRotateSphericalDragger self) -> SoType"},
	 { "SoRotateSphericalDragger_getClassNodekitCatalog", _wrap_SoRotateSphericalDragger_getClassNodekitCatalog, METH_NOARGS, "SoRotateSphericalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoRotateSphericalDragger_getNodekitCatalog", _wrap_SoRotateSphericalDragger_getNodekitCatalog, METH_O, "SoRotateSphericalDragger_getNodekitCatalog(SoRotateSphericalDragger self) -> SoNodekitCatalog"},
	 { "SoRotateSphericalDragger_initClass", _wrap_SoRotateSphericalDragger_initClass, METH_NOARGS, "SoRotateSphericalDragger_initClass()"},
	 { "new_SoRotateSphericalDragger", _wrap_new_SoRotateSphericalDragger, METH_NOARGS, "new_SoRotateSphericalDragger() -> SoRotateSphericalDragger"},
	 { "SoRotateSphericalDragger_rotation_set", _wrap_SoRotateSphericalDragger_rotation_set, METH_VARARGS, "SoRotateSphericalDragger_rotation_set(SoRotateSphericalDragger self, SoSFRotation rotation)"},
	 { "SoRotateSphericalDragger_rotation_get", _wrap_SoRotateSphericalDragger_rotation_get, METH_O, "SoRotateSphericalDragger_rotation_get(SoRotateSphericalDragger self) -> SoSFRotation"},
	 { "SoRotateSphericalDragger_setProjector", _wrap_SoRotateSphericalDragger_setProjector, METH_VARARGS, "SoRotateSphericalDragger_setProjector(SoRotateSphericalDragger self, SbSphereProjector p)"},
	 { "SoRotateSphericalDragger_getProjector", _wrap_SoRotateSphericalDragger_getProjector, METH_O, "SoRotateSphericalDragger_getProjector(SoRotateSphericalDragger self) -> SbSphereProjector"},
	 { "SoRotateSphericalDragger_swigregister", SoRotateSphericalDragger_swigregister, METH_O, NULL},
	 { "SoRotateSphericalDragger_swiginit", SoRotateSphericalDragger_swiginit, METH_VARARGS, NULL},
	 { "SoScale1Dragger_getClassTypeId", _wrap_SoScale1Dragger_getClassTypeId, METH_NOARGS, "SoScale1Dragger_getClassTypeId() -> SoType"},
	 { "SoScale1Dragger_getTypeId", _wrap_SoScale1Dragger_getTypeId, METH_O, "SoScale1Dragger_getTypeId(SoScale1Dragger self) -> SoType"},
	 { "SoScale1Dragger_getClassNodekitCatalog", _wrap_SoScale1Dragger_getClassNodekitCatalog, METH_NOARGS, "SoScale1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoScale1Dragger_getNodekitCatalog", _wrap_SoScale1Dragger_getNodekitCatalog, METH_O, "SoScale1Dragger_getNodekitCatalog(SoScale1Dragger self) -> SoNodekitCatalog"},
	 { "SoScale1Dragger_initClass", _wrap_SoScale1Dragger_initClass, METH_NOARGS, "SoScale1Dragger_initClass()"},
	 { "new_SoScale1Dragger", _wrap_new_SoScale1Dragger, METH_NOARGS, "new_SoScale1Dragger() -> SoScale1Dragger"},
	 { "SoScale1Dragger_scaleFactor_set", _wrap_SoScale1Dragger_scaleFactor_set, METH_VARARGS, "SoScale1Dragger_scaleFactor_set(SoScale1Dragger self, SoSFVec3f scaleFactor)"},
	 { "SoScale1Dragger_scaleFactor_get", _wrap_SoScale1Dragger_scaleFactor_get, METH_O, "SoScale1Dragger_scaleFactor_get(SoScale1Dragger self) -> SoSFVec3f"},
	 { "SoScale1Dragger_swigregister", SoScale1Dragger_swigregister, METH_O, NULL},
	 { "SoScale1Dragger_swiginit", SoScale1Dragger_swiginit, METH_VARARGS, NULL},
	 { "SoScale2Dragger_getClassTypeId", _wrap_SoScale2Dragger_getClassTypeId, METH_NOARGS, "SoScale2Dragger_getClassTypeId() -> SoType"},
	 { "SoScale2Dragger_getTypeId", _wrap_SoScale2Dragger_getTypeId, METH_O, "SoScale2Dragger_getTypeId(SoScale2Dragger self) -> SoType"},
	 { "SoScale2Dragger_getClassNodekitCatalog", _wrap_SoScale2Dragger_getClassNodekitCatalog, METH_NOARGS, "SoScale2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoScale2Dragger_getNodekitCatalog", _wrap_SoScale2Dragger_getNodekitCatalog, METH_O, "SoScale2Dragger_getNodekitCatalog(SoScale2Dragger self) -> SoNodekitCatalog"},
	 { "SoScale2Dragger_initClass", _wrap_SoScale2Dragger_initClass, METH_NOARGS, "SoScale2Dragger_initClass()"},
	 { "new_SoScale2Dragger", _wrap_new_SoScale2Dragger, METH_NOARGS, "new_SoScale2Dragger() -> SoScale2Dragger"},
	 { "SoScale2Dragger_scaleFactor_set", _wrap_SoScale2Dragger_scaleFactor_set, METH_VARARGS, "SoScale2Dragger_scaleFactor_set(SoScale2Dragger self, SoSFVec3f scaleFactor)"},
	 { "SoScale2Dragger_scaleFactor_get", _wrap_SoScale2Dragger_scaleFactor_get, METH_O, "SoScale2Dragger_scaleFactor_get(SoScale2Dragger self) -> SoSFVec3f"},
	 { "SoScale2Dragger_swigregister", SoScale2Dragger_swigregister, METH_O, NULL},
	 { "SoScale2Dragger_swiginit", SoScale2Dragger_swiginit, METH_VARARGS, NULL},
	 { "SoScale2UniformDragger_getClassTypeId", _wrap_SoScale2UniformDragger_getClassTypeId, METH_NOARGS, "SoScale2UniformDragger_getClassTypeId() -> SoType"},
	 { "SoScale2UniformDragger_getTypeId", _wrap_SoScale2UniformDragger_getTypeId, METH_O, "SoScale2UniformDragger_getTypeId(SoScale2UniformDragger self) -> SoType"},
	 { "SoScale2UniformDragger_getClassNodekitCatalog", _wrap_SoScale2UniformDragger_getClassNodekitCatalog, METH_NOARGS, "SoScale2UniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoScale2UniformDragger_getNodekitCatalog", _wrap_SoScale2UniformDragger_getNodekitCatalog, METH_O, "SoScale2UniformDragger_getNodekitCatalog(SoScale2UniformDragger self) -> SoNodekitCatalog"},
	 { "SoScale2UniformDragger_initClass", _wrap_SoScale2UniformDragger_initClass, METH_NOARGS, "SoScale2UniformDragger_initClass()"},
	 { "new_SoScale2UniformDragger", _wrap_new_SoScale2UniformDragger, METH_NOARGS, "new_SoScale2UniformDragger() -> SoScale2UniformDragger"},
	 { "SoScale2UniformDragger_scaleFactor_set", _wrap_SoScale2UniformDragger_scaleFactor_set, METH_VARARGS, "SoScale2UniformDragger_scaleFactor_set(SoScale2UniformDragger self, SoSFVec3f scaleFactor)"},
	 { "SoScale2UniformDragger_scaleFactor_get", _wrap_SoScale2UniformDragger_scaleFactor_get, METH_O, "SoScale2UniformDragger_scaleFactor_get(SoScale2UniformDragger self) -> SoSFVec3f"},
	 { "SoScale2UniformDragger_swigregister", SoScale2UniformDragger_swigregister, METH_O, NULL},
	 { "SoScale2UniformDragger_swiginit", SoScale2UniformDragger_swiginit, METH_VARARGS, NULL},
	 { "SoScaleUniformDragger_getClassTypeId", _wrap_SoScaleUniformDragger_getClassTypeId, METH_NOARGS, "SoScaleUniformDragger_getClassTypeId() -> SoType"},
	 { "SoScaleUniformDragger_getTypeId", _wrap_SoScaleUniformDragger_getTypeId, METH_O, "SoScaleUniformDragger_getTypeId(SoScaleUniformDragger self) -> SoType"},
	 { "SoScaleUniformDragger_getClassNodekitCatalog", _wrap_SoScaleUniformDragger_getClassNodekitCatalog, METH_NOARGS, "SoScaleUniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoScaleUniformDragger_getNodekitCatalog", _wrap_SoScaleUniformDragger_getNodekitCatalog, METH_O, "SoScaleUniformDragger_getNodekitCatalog(SoScaleUniformDragger self) -> SoNodekitCatalog"},
	 { "SoScaleUniformDragger_initClass", _wrap_SoScaleUniformDragger_initClass, METH_NOARGS, "SoScaleUniformDragger_initClass()"},
	 { "new_SoScaleUniformDragger", _wrap_new_SoScaleUniformDragger, METH_NOARGS, "new_SoScaleUniformDragger() -> SoScaleUniformDragger"},
	 { "SoScaleUniformDragger_scaleFactor_set", _wrap_SoScaleUniformDragger_scaleFactor_set, METH_VARARGS, "SoScaleUniformDragger_scaleFactor_set(SoScaleUniformDragger self, SoSFVec3f scaleFactor)"},
	 { "SoScaleUniformDragger_scaleFactor_get", _wrap_SoScaleUniformDragger_scaleFactor_get, METH_O, "SoScaleUniformDragger_scaleFactor_get(SoScaleUniformDragger self) -> SoSFVec3f"},
	 { "SoScaleUniformDragger_swigregister", SoScaleUniformDragger_swigregister, METH_O, NULL},
	 { "SoScaleUniformDragger_swiginit", SoScaleUniformDragger_swiginit, METH_VARARGS, NULL},
	 { "SoSpotLightDragger_getClassTypeId", _wrap_SoSpotLightDragger_getClassTypeId, METH_NOARGS, "SoSpotLightDragger_getClassTypeId() -> SoType"},
	 { "SoSpotLightDragger_getTypeId", _wrap_SoSpotLightDragger_getTypeId, METH_O, "SoSpotLightDragger_getTypeId(SoSpotLightDragger self) -> SoType"},
	 { "SoSpotLightDragger_getClassNodekitCatalog", _wrap_SoSpotLightDragger_getClassNodekitCatalog, METH_NOARGS, "SoSpotLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoSpotLightDragger_getNodekitCatalog", _wrap_SoSpotLightDragger_getNodekitCatalog, METH_O, "SoSpotLightDragger_getNodekitCatalog(SoSpotLightDragger self) -> SoNodekitCatalog"},
	 { "SoSpotLightDragger_initClass", _wrap_SoSpotLightDragger_initClass, METH_NOARGS, "SoSpotLightDragger_initClass()"},
	 { "new_SoSpotLightDragger", _wrap_new_SoSpotLightDragger, METH_NOARGS, "new_SoSpotLightDragger() -> SoSpotLightDragger"},
	 { "SoSpotLightDragger_rotation_set", _wrap_SoSpotLightDragger_rotation_set, METH_VARARGS, "SoSpotLightDragger_rotation_set(SoSpotLightDragger self, SoSFRotation rotation)"},
	 { "SoSpotLightDragger_rotation_get", _wrap_SoSpotLightDragger_rotation_get, METH_O, "SoSpotLightDragger_rotation_get(SoSpotLightDragger self) -> SoSFRotation"},
	 { "SoSpotLightDragger_translation_set", _wrap_SoSpotLightDragger_translation_set, METH_VARARGS, "SoSpotLightDragger_translation_set(SoSpotLightDragger self, SoSFVec3f translation)"},
	 { "SoSpotLightDragger_translation_get", _wrap_SoSpotLightDragger_translation_get, METH_O, "SoSpotLightDragger_translation_get(SoSpotLightDragger self) -> SoSFVec3f"},
	 { "SoSpotLightDragger_angle_set", _wrap_SoSpotLightDragger_angle_set, METH_VARARGS, "SoSpotLightDragger_angle_set(SoSpotLightDragger self, SoSFFloat angle)"},
	 { "SoSpotLightDragger_angle_get", _wrap_SoSpotLightDragger_angle_get, METH_O, "SoSpotLightDragger_angle_get(SoSpotLightDragger self) -> SoSFFloat"},
	 { "SoSpotLightDragger_swigregister", SoSpotLightDragger_swigregister, METH_O, NULL},
	 { "SoSpotLightDragger_swiginit", SoSpotLightDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTabBoxDragger_getClassTypeId", _wrap_SoTabBoxDragger_getClassTypeId, METH_NOARGS, "SoTabBoxDragger_getClassTypeId() -> SoType"},
	 { "SoTabBoxDragger_getTypeId", _wrap_SoTabBoxDragger_getTypeId, METH_O, "SoTabBoxDragger_getTypeId(SoTabBoxDragger self) -> SoType"},
	 { "SoTabBoxDragger_getClassNodekitCatalog", _wrap_SoTabBoxDragger_getClassNodekitCatalog, METH_NOARGS, "SoTabBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTabBoxDragger_getNodekitCatalog", _wrap_SoTabBoxDragger_getNodekitCatalog, METH_O, "SoTabBoxDragger_getNodekitCatalog(SoTabBoxDragger self) -> SoNodekitCatalog"},
	 { "SoTabBoxDragger_initClass", _wrap_SoTabBoxDragger_initClass, METH_NOARGS, "SoTabBoxDragger_initClass()"},
	 { "new_SoTabBoxDragger", _wrap_new_SoTabBoxDragger, METH_NOARGS, "new_SoTabBoxDragger() -> SoTabBoxDragger"},
	 { "SoTabBoxDragger_translation_set", _wrap_SoTabBoxDragger_translation_set, METH_VARARGS, "SoTabBoxDragger_translation_set(SoTabBoxDragger self, SoSFVec3f translation)"},
	 { "SoTabBoxDragger_translation_get", _wrap_SoTabBoxDragger_translation_get, METH_O, "SoTabBoxDragger_translation_get(SoTabBoxDragger self) -> SoSFVec3f"},
	 { "SoTabBoxDragger_scaleFactor_set", _wrap_SoTabBoxDragger_scaleFactor_set, METH_VARARGS, "SoTabBoxDragger_scaleFactor_set(SoTabBoxDragger self, SoSFVec3f scaleFactor)"},
	 { "SoTabBoxDragger_scaleFactor_get", _wrap_SoTabBoxDragger_scaleFactor_get, METH_O, "SoTabBoxDragger_scaleFactor_get(SoTabBoxDragger self) -> SoSFVec3f"},
	 { "SoTabBoxDragger_adjustScaleTabSize", _wrap_SoTabBoxDragger_adjustScaleTabSize, METH_O, "SoTabBoxDragger_adjustScaleTabSize(SoTabBoxDragger self)"},
	 { "SoTabBoxDragger_swigregister", SoTabBoxDragger_swigregister, METH_O, NULL},
	 { "SoTabBoxDragger_swiginit", SoTabBoxDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTabPlaneDragger_getClassTypeId", _wrap_SoTabPlaneDragger_getClassTypeId, METH_NOARGS, "SoTabPlaneDragger_getClassTypeId() -> SoType"},
	 { "SoTabPlaneDragger_getTypeId", _wrap_SoTabPlaneDragger_getTypeId, METH_O, "SoTabPlaneDragger_getTypeId(SoTabPlaneDragger self) -> SoType"},
	 { "SoTabPlaneDragger_getClassNodekitCatalog", _wrap_SoTabPlaneDragger_getClassNodekitCatalog, METH_NOARGS, "SoTabPlaneDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTabPlaneDragger_getNodekitCatalog", _wrap_SoTabPlaneDragger_getNodekitCatalog, METH_O, "SoTabPlaneDragger_getNodekitCatalog(SoTabPlaneDragger self) -> SoNodekitCatalog"},
	 { "SoTabPlaneDragger_initClass", _wrap_SoTabPlaneDragger_initClass, METH_NOARGS, "SoTabPlaneDragger_initClass()"},
	 { "new_SoTabPlaneDragger", _wrap_new_SoTabPlaneDragger, METH_NOARGS, "new_SoTabPlaneDragger() -> SoTabPlaneDragger"},
	 { "SoTabPlaneDragger_translation_set", _wrap_SoTabPlaneDragger_translation_set, METH_VARARGS, "SoTabPlaneDragger_translation_set(SoTabPlaneDragger self, SoSFVec3f translation)"},
	 { "SoTabPlaneDragger_translation_get", _wrap_SoTabPlaneDragger_translation_get, METH_O, "SoTabPlaneDragger_translation_get(SoTabPlaneDragger self) -> SoSFVec3f"},
	 { "SoTabPlaneDragger_scaleFactor_set", _wrap_SoTabPlaneDragger_scaleFactor_set, METH_VARARGS, "SoTabPlaneDragger_scaleFactor_set(SoTabPlaneDragger self, SoSFVec3f scaleFactor)"},
	 { "SoTabPlaneDragger_scaleFactor_get", _wrap_SoTabPlaneDragger_scaleFactor_get, METH_O, "SoTabPlaneDragger_scaleFactor_get(SoTabPlaneDragger self) -> SoSFVec3f"},
	 { "SoTabPlaneDragger_adjustScaleTabSize", _wrap_SoTabPlaneDragger_adjustScaleTabSize, METH_O, "SoTabPlaneDragger_adjustScaleTabSize(SoTabPlaneDragger self)"},
	 { "SoTabPlaneDragger_swigregister", SoTabPlaneDragger_swigregister, METH_O, NULL},
	 { "SoTabPlaneDragger_swiginit", SoTabPlaneDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTrackballDragger_getClassTypeId", _wrap_SoTrackballDragger_getClassTypeId, METH_NOARGS, "SoTrackballDragger_getClassTypeId() -> SoType"},
	 { "SoTrackballDragger_getTypeId", _wrap_SoTrackballDragger_getTypeId, METH_O, "SoTrackballDragger_getTypeId(SoTrackballDragger self) -> SoType"},
	 { "SoTrackballDragger_getClassNodekitCatalog", _wrap_SoTrackballDragger_getClassNodekitCatalog, METH_NOARGS, "SoTrackballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTrackballDragger_getNodekitCatalog", _wrap_SoTrackballDragger_getNodekitCatalog, METH_O, "SoTrackballDragger_getNodekitCatalog(SoTrackballDragger self) -> SoNodekitCatalog"},
	 { "SoTrackballDragger_initClass", _wrap_SoTrackballDragger_initClass, METH_NOARGS, "SoTrackballDragger_initClass()"},
	 { "new_SoTrackballDragger", _wrap_new_SoTrackballDragger, METH_NOARGS, "new_SoTrackballDragger() -> SoTrackballDragger"},
	 { "SoTrackballDragger_rotation_set", _wrap_SoTrackballDragger_rotation_set, METH_VARARGS, "SoTrackballDragger_rotation_set(SoTrackballDragger self, SoSFRotation rotation)"},
	 { "SoTrackballDragger_rotation_get", _wrap_SoTrackballDragger_rotation_get, METH_O, "SoTrackballDragger_rotation_get(SoTrackballDragger self) -> SoSFRotation"},
	 { "SoTrackballDragger_scaleFactor_set", _wrap_SoTrackballDragger_scaleFactor_set, METH_VARARGS, "SoTrackballDragger_scaleFactor_set(SoTrackballDragger self, SoSFVec3f scaleFactor)"},
	 { "SoTrackballDragger_scaleFactor_get", _wrap_SoTrackballDragger_scaleFactor_get, METH_O, "SoTrackballDragger_scaleFactor_get(SoTrackballDragger self) -> SoSFVec3f"},
	 { "SoTrackballDragger_isAnimationEnabled", _wrap_SoTrackballDragger_isAnimationEnabled, METH_O, "SoTrackballDragger_isAnimationEnabled(SoTrackballDragger self) -> SbBool"},
	 { "SoTrackballDragger_setAnimationEnabled", _wrap_SoTrackballDragger_setAnimationEnabled, METH_VARARGS, "SoTrackballDragger_setAnimationEnabled(SoTrackballDragger self, SbBool newval)"},
	 { "SoTrackballDragger_swigregister", SoTrackballDragger_swigregister, METH_O, NULL},
	 { "SoTrackballDragger_swiginit", SoTrackballDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTransformBoxDragger_getClassTypeId", _wrap_SoTransformBoxDragger_getClassTypeId, METH_NOARGS, "SoTransformBoxDragger_getClassTypeId() -> SoType"},
	 { "SoTransformBoxDragger_getTypeId", _wrap_SoTransformBoxDragger_getTypeId, METH_O, "SoTransformBoxDragger_getTypeId(SoTransformBoxDragger self) -> SoType"},
	 { "SoTransformBoxDragger_getClassNodekitCatalog", _wrap_SoTransformBoxDragger_getClassNodekitCatalog, METH_NOARGS, "SoTransformBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTransformBoxDragger_getNodekitCatalog", _wrap_SoTransformBoxDragger_getNodekitCatalog, METH_O, "SoTransformBoxDragger_getNodekitCatalog(SoTransformBoxDragger self) -> SoNodekitCatalog"},
	 { "SoTransformBoxDragger_initClass", _wrap_SoTransformBoxDragger_initClass, METH_NOARGS, "SoTransformBoxDragger_initClass()"},
	 { "new_SoTransformBoxDragger", _wrap_new_SoTransformBoxDragger, METH_NOARGS, "new_SoTransformBoxDragger() -> SoTransformBoxDragger"},
	 { "SoTransformBoxDragger_rotation_set", _wrap_SoTransformBoxDragger_rotation_set, METH_VARARGS, "SoTransformBoxDragger_rotation_set(SoTransformBoxDragger self, SoSFRotation rotation)"},
	 { "SoTransformBoxDragger_rotation_get", _wrap_SoTransformBoxDragger_rotation_get, METH_O, "SoTransformBoxDragger_rotation_get(SoTransformBoxDragger self) -> SoSFRotation"},
	 { "SoTransformBoxDragger_translation_set", _wrap_SoTransformBoxDragger_translation_set, METH_VARARGS, "SoTransformBoxDragger_translation_set(SoTransformBoxDragger self, SoSFVec3f translation)"},
	 { "SoTransformBoxDragger_translation_get", _wrap_SoTransformBoxDragger_translation_get, METH_O, "SoTransformBoxDragger_translation_get(SoTransformBoxDragger self) -> SoSFVec3f"},
	 { "SoTransformBoxDragger_scaleFactor_set", _wrap_SoTransformBoxDragger_scaleFactor_set, METH_VARARGS, "SoTransformBoxDragger_scaleFactor_set(SoTransformBoxDragger self, SoSFVec3f scaleFactor)"},
	 { "SoTransformBoxDragger_scaleFactor_get", _wrap_SoTransformBoxDragger_scaleFactor_get, METH_O, "SoTransformBoxDragger_scaleFactor_get(SoTransformBoxDragger self) -> SoSFVec3f"},
	 { "SoTransformBoxDragger_swigregister", SoTransformBoxDragger_swigregister, METH_O, NULL},
	 { "SoTransformBoxDragger_swiginit", SoTransformBoxDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTransformerDragger_getClassTypeId", _wrap_SoTransformerDragger_getClassTypeId, METH_NOARGS, "SoTransformerDragger_getClassTypeId() -> SoType"},
	 { "SoTransformerDragger_getTypeId", _wrap_SoTransformerDragger_getTypeId, METH_O, "SoTransformerDragger_getTypeId(SoTransformerDragger self) -> SoType"},
	 { "SoTransformerDragger_getClassNodekitCatalog", _wrap_SoTransformerDragger_getClassNodekitCatalog, METH_NOARGS, "SoTransformerDragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTransformerDragger_getNodekitCatalog", _wrap_SoTransformerDragger_getNodekitCatalog, METH_O, "SoTransformerDragger_getNodekitCatalog(SoTransformerDragger self) -> SoNodekitCatalog"},
	 { "SoTransformerDragger_initClass", _wrap_SoTransformerDragger_initClass, METH_NOARGS, "SoTransformerDragger_initClass()"},
	 { "new_SoTransformerDragger", _wrap_new_SoTransformerDragger, METH_NOARGS, "new_SoTransformerDragger() -> SoTransformerDragger"},
	 { "SoTransformerDragger_rotation_set", _wrap_SoTransformerDragger_rotation_set, METH_VARARGS, "SoTransformerDragger_rotation_set(SoTransformerDragger self, SoSFRotation rotation)"},
	 { "SoTransformerDragger_rotation_get", _wrap_SoTransformerDragger_rotation_get, METH_O, "SoTransformerDragger_rotation_get(SoTransformerDragger self) -> SoSFRotation"},
	 { "SoTransformerDragger_translation_set", _wrap_SoTransformerDragger_translation_set, METH_VARARGS, "SoTransformerDragger_translation_set(SoTransformerDragger self, SoSFVec3f translation)"},
	 { "SoTransformerDragger_translation_get", _wrap_SoTransformerDragger_translation_get, METH_O, "SoTransformerDragger_translation_get(SoTransformerDragger self) -> SoSFVec3f"},
	 { "SoTransformerDragger_scaleFactor_set", _wrap_SoTransformerDragger_scaleFactor_set, METH_VARARGS, "SoTransformerDragger_scaleFactor_set(SoTransformerDragger self, SoSFVec3f scaleFactor)"},
	 { "SoTransformerDragger_scaleFactor_get", _wrap_SoTransformerDragger_scaleFactor_get, METH_O, "SoTransformerDragger_scaleFactor_get(SoTransformerDragger self) -> SoSFVec3f"},
	 { "SoTransformerDragger_minDiscRotDot_set", _wrap_SoTransformerDragger_minDiscRotDot_set, METH_VARARGS, "SoTransformerDragger_minDiscRotDot_set(SoTransformerDragger self, SoSFFloat minDiscRotDot)"},
	 { "SoTransformerDragger_minDiscRotDot_get", _wrap_SoTransformerDragger_minDiscRotDot_get, METH_O, "SoTransformerDragger_minDiscRotDot_get(SoTransformerDragger self) -> SoSFFloat"},
	 { "SoTransformerDragger_getCurrentState", _wrap_SoTransformerDragger_getCurrentState, METH_O, "SoTransformerDragger_getCurrentState(SoTransformerDragger self) -> SoTransformerDragger::State"},
	 { "SoTransformerDragger_unsquishKnobs", _wrap_SoTransformerDragger_unsquishKnobs, METH_O, "SoTransformerDragger_unsquishKnobs(SoTransformerDragger self)"},
	 { "SoTransformerDragger_isLocateHighlighting", _wrap_SoTransformerDragger_isLocateHighlighting, METH_O, "SoTransformerDragger_isLocateHighlighting(SoTransformerDragger self) -> SbBool"},
	 { "SoTransformerDragger_setLocateHighlighting", _wrap_SoTransformerDragger_setLocateHighlighting, METH_VARARGS, "SoTransformerDragger_setLocateHighlighting(SoTransformerDragger self, SbBool onoff)"},
	 { "SoTransformerDragger_setColinearThreshold", _wrap_SoTransformerDragger_setColinearThreshold, METH_O, "SoTransformerDragger_setColinearThreshold(int newval)"},
	 { "SoTransformerDragger_getColinearThreshold", _wrap_SoTransformerDragger_getColinearThreshold, METH_NOARGS, "SoTransformerDragger_getColinearThreshold() -> int"},
	 { "SoTransformerDragger_getBoxPointInWorldSpace", _wrap_SoTransformerDragger_getBoxPointInWorldSpace, METH_VARARGS, "SoTransformerDragger_getBoxPointInWorldSpace(SoTransformerDragger self, SbVec3f pointonunitbox) -> SbVec3f"},
	 { "SoTransformerDragger_getBoxDirInWorldSpace", _wrap_SoTransformerDragger_getBoxDirInWorldSpace, METH_VARARGS, "SoTransformerDragger_getBoxDirInWorldSpace(SoTransformerDragger self, SbVec3f dironunitbox) -> SbVec3f"},
	 { "SoTransformerDragger_getWorldPointInBoxSpace", _wrap_SoTransformerDragger_getWorldPointInBoxSpace, METH_VARARGS, "SoTransformerDragger_getWorldPointInBoxSpace(SoTransformerDragger self, SbVec3f pointinworldspace) -> SbVec3f"},
	 { "SoTransformerDragger_getWorldPointInPixelSpace", _wrap_SoTransformerDragger_getWorldPointInPixelSpace, METH_VARARGS, "SoTransformerDragger_getWorldPointInPixelSpace(SoTransformerDragger self, SbVec3f thepoint) -> SbVec2f"},
	 { "SoTransformerDragger_getInteractiveCenterInBoxSpace", _wrap_SoTransformerDragger_getInteractiveCenterInBoxSpace, METH_O, "SoTransformerDragger_getInteractiveCenterInBoxSpace(SoTransformerDragger self) -> SbVec3f"},
	 { "SoTransformerDragger_swigregister", SoTransformerDragger_swigregister, METH_O, NULL},
	 { "SoTransformerDragger_swiginit", SoTransformerDragger_swiginit, METH_VARARGS, NULL},
	 { "SoTranslate1Dragger_getClassTypeId", _wrap_SoTranslate1Dragger_getClassTypeId, METH_NOARGS, "SoTranslate1Dragger_getClassTypeId() -> SoType"},
	 { "SoTranslate1Dragger_getTypeId", _wrap_SoTranslate1Dragger_getTypeId, METH_O, "SoTranslate1Dragger_getTypeId(SoTranslate1Dragger self) -> SoType"},
	 { "SoTranslate1Dragger_getClassNodekitCatalog", _wrap_SoTranslate1Dragger_getClassNodekitCatalog, METH_NOARGS, "SoTranslate1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTranslate1Dragger_getNodekitCatalog", _wrap_SoTranslate1Dragger_getNodekitCatalog, METH_O, "SoTranslate1Dragger_getNodekitCatalog(SoTranslate1Dragger self) -> SoNodekitCatalog"},
	 { "SoTranslate1Dragger_initClass", _wrap_SoTranslate1Dragger_initClass, METH_NOARGS, "SoTranslate1Dragger_initClass()"},
	 { "new_SoTranslate1Dragger", _wrap_new_SoTranslate1Dragger, METH_NOARGS, "new_SoTranslate1Dragger() -> SoTranslate1Dragger"},
	 { "SoTranslate1Dragger_translation_set", _wrap_SoTranslate1Dragger_translation_set, METH_VARARGS, "SoTranslate1Dragger_translation_set(SoTranslate1Dragger self, SoSFVec3f translation)"},
	 { "SoTranslate1Dragger_translation_get", _wrap_SoTranslate1Dragger_translation_get, METH_O, "SoTranslate1Dragger_translation_get(SoTranslate1Dragger self) -> SoSFVec3f"},
	 { "SoTranslate1Dragger_minTranslation_set", _wrap_SoTranslate1Dragger_minTranslation_set, METH_VARARGS, "SoTranslate1Dragger_minTranslation_set(SoTranslate1Dragger self, SoSFFloat minTranslation)"},
	 { "SoTranslate1Dragger_minTranslation_get", _wrap_SoTranslate1Dragger_minTranslation_get, METH_O, "SoTranslate1Dragger_minTranslation_get(SoTranslate1Dragger self) -> SoSFFloat"},
	 { "SoTranslate1Dragger_maxTranslation_set", _wrap_SoTranslate1Dragger_maxTranslation_set, METH_VARARGS, "SoTranslate1Dragger_maxTranslation_set(SoTranslate1Dragger self, SoSFFloat maxTranslation)"},
	 { "SoTranslate1Dragger_maxTranslation_get", _wrap_SoTranslate1Dragger_maxTranslation_get, METH_O, "SoTranslate1Dragger_maxTranslation_get(SoTranslate1Dragger self) -> SoSFFloat"},
	 { "SoTranslate1Dragger_swigregister", SoTranslate1Dragger_swigregister, METH_O, NULL},
	 { "SoTranslate1Dragger_swiginit", SoTranslate1Dragger_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec2f", _wrap_new_SoSFVec2f, METH_NOARGS, "new_SoSFVec2f() -> SoSFVec2f"},
	 { "delete_SoSFVec2f", _wrap_delete_SoSFVec2f, METH_O, "delete_SoSFVec2f(SoSFVec2f self)"},
	 { "SoSFVec2f_createInstance", _wrap_SoSFVec2f_createInstance, METH_NOARGS, "SoSFVec2f_createInstance() -> void *"},
	 { "SoSFVec2f_getClassTypeId", _wrap_SoSFVec2f_getClassTypeId, METH_NOARGS, "SoSFVec2f_getClassTypeId() -> SoType"},
	 { "SoSFVec2f_getTypeId", _wrap_SoSFVec2f_getTypeId, METH_O, "SoSFVec2f_getTypeId(SoSFVec2f self) -> SoType"},
	 { "SoSFVec2f_copyFrom", _wrap_SoSFVec2f_copyFrom, METH_VARARGS, "SoSFVec2f_copyFrom(SoSFVec2f self, SoField field)"},
	 { "SoSFVec2f_isSame", _wrap_SoSFVec2f_isSame, METH_VARARGS, "SoSFVec2f_isSame(SoSFVec2f self, SoField field) -> SbBool"},
	 { "SoSFVec2f_getValue", _wrap_SoSFVec2f_getValue, METH_O, "SoSFVec2f_getValue(SoSFVec2f self) -> SbVec2f"},
	 { "SoSFVec2f___eq__", _wrap_SoSFVec2f___eq__, METH_VARARGS, "SoSFVec2f___eq__(SoSFVec2f self, SoSFVec2f field) -> int"},
	 { "SoSFVec2f___ne__", _wrap_SoSFVec2f___ne__, METH_VARARGS, "SoSFVec2f___ne__(SoSFVec2f self, SoSFVec2f field) -> int"},
	 { "SoSFVec2f_initClass", _wrap_SoSFVec2f_initClass, METH_NOARGS, "SoSFVec2f_initClass()"},
	 { "SoSFVec2f_setValue", _wrap_SoSFVec2f_setValue, METH_VARARGS, "\n"
		"SoSFVec2f_setValue(SoSFVec2f self, SbVec2f newvalue)\n"
		"SoSFVec2f_setValue(SoSFVec2f self, float x, float y)\n"
		"SoSFVec2f_setValue(SoSFVec2f self, float const [2] xy)\n"
		"SoSFVec2f_setValue(SoSFVec2f self, SoSFVec2f other)\n"
		""},
	 { "SoSFVec2f_swigregister", SoSFVec2f_swigregister, METH_O, NULL},
	 { "SoSFVec2f_swiginit", SoSFVec2f_swiginit, METH_VARARGS, NULL},
	 { "SoTranslate2Dragger_getClassTypeId", _wrap_SoTranslate2Dragger_getClassTypeId, METH_NOARGS, "SoTranslate2Dragger_getClassTypeId() -> SoType"},
	 { "SoTranslate2Dragger_getTypeId", _wrap_SoTranslate2Dragger_getTypeId, METH_O, "SoTranslate2Dragger_getTypeId(SoTranslate2Dragger self) -> SoType"},
	 { "SoTranslate2Dragger_getClassNodekitCatalog", _wrap_SoTranslate2Dragger_getClassNodekitCatalog, METH_NOARGS, "SoTranslate2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoTranslate2Dragger_getNodekitCatalog", _wrap_SoTranslate2Dragger_getNodekitCatalog, METH_O, "SoTranslate2Dragger_getNodekitCatalog(SoTranslate2Dragger self) -> SoNodekitCatalog"},
	 { "SoTranslate2Dragger_initClass", _wrap_SoTranslate2Dragger_initClass, METH_NOARGS, "SoTranslate2Dragger_initClass()"},
	 { "new_SoTranslate2Dragger", _wrap_new_SoTranslate2Dragger, METH_NOARGS, "new_SoTranslate2Dragger() -> SoTranslate2Dragger"},
	 { "SoTranslate2Dragger_translation_set", _wrap_SoTranslate2Dragger_translation_set, METH_VARARGS, "SoTranslate2Dragger_translation_set(SoTranslate2Dragger self, SoSFVec3f translation)"},
	 { "SoTranslate2Dragger_translation_get", _wrap_SoTranslate2Dragger_translation_get, METH_O, "SoTranslate2Dragger_translation_get(SoTranslate2Dragger self) -> SoSFVec3f"},
	 { "SoTranslate2Dragger_minTranslation_set", _wrap_SoTranslate2Dragger_minTranslation_set, METH_VARARGS, "SoTranslate2Dragger_minTranslation_set(SoTranslate2Dragger self, SoSFVec2f minTranslation)"},
	 { "SoTranslate2Dragger_minTranslation_get", _wrap_SoTranslate2Dragger_minTranslation_get, METH_O, "SoTranslate2Dragger_minTranslation_get(SoTranslate2Dragger self) -> SoSFVec2f"},
	 { "SoTranslate2Dragger_maxTranslation_set", _wrap_SoTranslate2Dragger_maxTranslation_set, METH_VARARGS, "SoTranslate2Dragger_maxTranslation_set(SoTranslate2Dragger self, SoSFVec2f maxTranslation)"},
	 { "SoTranslate2Dragger_maxTranslation_get", _wrap_SoTranslate2Dragger_maxTranslation_get, METH_O, "SoTranslate2Dragger_maxTranslation_get(SoTranslate2Dragger self) -> SoSFVec2f"},
	 { "SoTranslate2Dragger_swigregister", SoTranslate2Dragger_swigregister, METH_O, NULL},
	 { "SoTranslate2Dragger_swiginit", SoTranslate2Dragger_swiginit, METH_VARARGS, NULL},
	 { "SoAccumulatedElement_getClassTypeId", _wrap_SoAccumulatedElement_getClassTypeId, METH_NOARGS, "SoAccumulatedElement_getClassTypeId() -> SoType"},
	 { "SoAccumulatedElement_getClassStackIndex", _wrap_SoAccumulatedElement_getClassStackIndex, METH_NOARGS, "SoAccumulatedElement_getClassStackIndex() -> int"},
	 { "SoAccumulatedElement_initClass", _wrap_SoAccumulatedElement_initClass, METH_NOARGS, "SoAccumulatedElement_initClass()"},
	 { "SoAccumulatedElement_matches", _wrap_SoAccumulatedElement_matches, METH_VARARGS, "SoAccumulatedElement_matches(SoAccumulatedElement self, SoElement element) -> SbBool"},
	 { "SoAccumulatedElement_swigregister", SoAccumulatedElement_swigregister, METH_O, NULL},
	 { "SoAmbientColorElement_getClassTypeId", _wrap_SoAmbientColorElement_getClassTypeId, METH_NOARGS, "SoAmbientColorElement_getClassTypeId() -> SoType"},
	 { "SoAmbientColorElement_getClassStackIndex", _wrap_SoAmbientColorElement_getClassStackIndex, METH_NOARGS, "SoAmbientColorElement_getClassStackIndex() -> int"},
	 { "SoAmbientColorElement_createInstance", _wrap_SoAmbientColorElement_createInstance, METH_NOARGS, "SoAmbientColorElement_createInstance() -> void *"},
	 { "SoAmbientColorElement_initClass", _wrap_SoAmbientColorElement_initClass, METH_NOARGS, "SoAmbientColorElement_initClass()"},
	 { "SoAmbientColorElement_init", _wrap_SoAmbientColorElement_init, METH_VARARGS, "SoAmbientColorElement_init(SoAmbientColorElement self, SoState state)"},
	 { "SoAmbientColorElement_set", _wrap_SoAmbientColorElement_set, METH_VARARGS, "SoAmbientColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"},
	 { "SoAmbientColorElement_getInstance", _wrap_SoAmbientColorElement_getInstance, METH_O, "SoAmbientColorElement_getInstance(SoState state) -> SoAmbientColorElement"},
	 { "SoAmbientColorElement_getNum", _wrap_SoAmbientColorElement_getNum, METH_O, "SoAmbientColorElement_getNum(SoAmbientColorElement self) -> int32_t"},
	 { "SoAmbientColorElement_get", _wrap_SoAmbientColorElement_get, METH_VARARGS, "SoAmbientColorElement_get(SoAmbientColorElement self, int const index) -> SbColor"},
	 { "SoAmbientColorElement_getArrayPtr", _wrap_SoAmbientColorElement_getArrayPtr, METH_O, "SoAmbientColorElement_getArrayPtr(SoAmbientColorElement self) -> SbColor"},
	 { "SoAmbientColorElement_swigregister", SoAmbientColorElement_swigregister, METH_O, NULL},
	 { "SoAnnoText3CharOrientElement_getClassTypeId", _wrap_SoAnnoText3CharOrientElement_getClassTypeId, METH_NOARGS, "SoAnnoText3CharOrientElement_getClassTypeId() -> SoType"},
	 { "SoAnnoText3CharOrientElement_getClassStackIndex", _wrap_SoAnnoText3CharOrientElement_getClassStackIndex, METH_NOARGS, "SoAnnoText3CharOrientElement_getClassStackIndex() -> int"},
	 { "SoAnnoText3CharOrientElement_createInstance", _wrap_SoAnnoText3CharOrientElement_createInstance, METH_NOARGS, "SoAnnoText3CharOrientElement_createInstance() -> void *"},
	 { "SoAnnoText3CharOrientElement_initClass", _wrap_SoAnnoText3CharOrientElement_initClass, METH_NOARGS, "SoAnnoText3CharOrientElement_initClass()"},
	 { "SoAnnoText3CharOrientElement_init", _wrap_SoAnnoText3CharOrientElement_init, METH_VARARGS, "SoAnnoText3CharOrientElement_init(SoAnnoText3CharOrientElement self, SoState state)"},
	 { "SoAnnoText3CharOrientElement_set", _wrap_SoAnnoText3CharOrientElement_set, METH_VARARGS, "SoAnnoText3CharOrientElement_set(SoState state, SbBool isOriented)"},
	 { "SoAnnoText3CharOrientElement_get", _wrap_SoAnnoText3CharOrientElement_get, METH_O, "SoAnnoText3CharOrientElement_get(SoState state) -> SbBool"},
	 { "SoAnnoText3CharOrientElement_getDefault", _wrap_SoAnnoText3CharOrientElement_getDefault, METH_NOARGS, "SoAnnoText3CharOrientElement_getDefault() -> SbBool"},
	 { "SoAnnoText3CharOrientElement_swigregister", SoAnnoText3CharOrientElement_swigregister, METH_O, NULL},
	 { "SoAnnoText3FontSizeHintElement_getClassTypeId", _wrap_SoAnnoText3FontSizeHintElement_getClassTypeId, METH_NOARGS, "SoAnnoText3FontSizeHintElement_getClassTypeId() -> SoType"},
	 { "SoAnnoText3FontSizeHintElement_getClassStackIndex", _wrap_SoAnnoText3FontSizeHintElement_getClassStackIndex, METH_NOARGS, "SoAnnoText3FontSizeHintElement_getClassStackIndex() -> int"},
	 { "SoAnnoText3FontSizeHintElement_createInstance", _wrap_SoAnnoText3FontSizeHintElement_createInstance, METH_NOARGS, "SoAnnoText3FontSizeHintElement_createInstance() -> void *"},
	 { "SoAnnoText3FontSizeHintElement_initClass", _wrap_SoAnnoText3FontSizeHintElement_initClass, METH_NOARGS, "SoAnnoText3FontSizeHintElement_initClass()"},
	 { "SoAnnoText3FontSizeHintElement_init", _wrap_SoAnnoText3FontSizeHintElement_init, METH_VARARGS, "SoAnnoText3FontSizeHintElement_init(SoAnnoText3FontSizeHintElement self, SoState state)"},
	 { "SoAnnoText3FontSizeHintElement_get", _wrap_SoAnnoText3FontSizeHintElement_get, METH_O, "SoAnnoText3FontSizeHintElement_get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"},
	 { "SoAnnoText3FontSizeHintElement_getDefault", _wrap_SoAnnoText3FontSizeHintElement_getDefault, METH_NOARGS, "SoAnnoText3FontSizeHintElement_getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"},
	 { "SoAnnoText3FontSizeHintElement_set", _wrap_SoAnnoText3FontSizeHintElement_set, METH_VARARGS, "\n"
		"SoAnnoText3FontSizeHintElement_set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)\n"
		"SoAnnoText3FontSizeHintElement_set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)\n"
		""},
	 { "SoAnnoText3FontSizeHintElement_swigregister", SoAnnoText3FontSizeHintElement_swigregister, METH_O, NULL},
	 { "SoAnnoText3RenderPrintElement_getClassTypeId", _wrap_SoAnnoText3RenderPrintElement_getClassTypeId, METH_NOARGS, "SoAnnoText3RenderPrintElement_getClassTypeId() -> SoType"},
	 { "SoAnnoText3RenderPrintElement_getClassStackIndex", _wrap_SoAnnoText3RenderPrintElement_getClassStackIndex, METH_NOARGS, "SoAnnoText3RenderPrintElement_getClassStackIndex() -> int"},
	 { "SoAnnoText3RenderPrintElement_createInstance", _wrap_SoAnnoText3RenderPrintElement_createInstance, METH_NOARGS, "SoAnnoText3RenderPrintElement_createInstance() -> void *"},
	 { "SoAnnoText3RenderPrintElement_initClass", _wrap_SoAnnoText3RenderPrintElement_initClass, METH_NOARGS, "SoAnnoText3RenderPrintElement_initClass()"},
	 { "SoAnnoText3RenderPrintElement_init", _wrap_SoAnnoText3RenderPrintElement_init, METH_VARARGS, "SoAnnoText3RenderPrintElement_init(SoAnnoText3RenderPrintElement self, SoState state)"},
	 { "SoAnnoText3RenderPrintElement_get", _wrap_SoAnnoText3RenderPrintElement_get, METH_O, "SoAnnoText3RenderPrintElement_get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"},
	 { "SoAnnoText3RenderPrintElement_getDefault", _wrap_SoAnnoText3RenderPrintElement_getDefault, METH_NOARGS, "SoAnnoText3RenderPrintElement_getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"},
	 { "SoAnnoText3RenderPrintElement_set", _wrap_SoAnnoText3RenderPrintElement_set, METH_VARARGS, "\n"
		"SoAnnoText3RenderPrintElement_set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)\n"
		"SoAnnoText3RenderPrintElement_set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)\n"
		""},
	 { "SoAnnoText3RenderPrintElement_swigregister", SoAnnoText3RenderPrintElement_swigregister, METH_O, NULL},
	 { "SoModelMatrixElement_getClassTypeId", _wrap_SoModelMatrixElement_getClassTypeId, METH_NOARGS, "SoModelMatrixElement_getClassTypeId() -> SoType"},
	 { "SoModelMatrixElement_getClassStackIndex", _wrap_SoModelMatrixElement_getClassStackIndex, METH_NOARGS, "SoModelMatrixElement_getClassStackIndex() -> int"},
	 { "SoModelMatrixElement_createInstance", _wrap_SoModelMatrixElement_createInstance, METH_NOARGS, "SoModelMatrixElement_createInstance() -> void *"},
	 { "SoModelMatrixElement_initClass", _wrap_SoModelMatrixElement_initClass, METH_NOARGS, "SoModelMatrixElement_initClass()"},
	 { "SoModelMatrixElement_init", _wrap_SoModelMatrixElement_init, METH_VARARGS, "SoModelMatrixElement_init(SoModelMatrixElement self, SoState state)"},
	 { "SoModelMatrixElement_push", _wrap_SoModelMatrixElement_push, METH_VARARGS, "SoModelMatrixElement_push(SoModelMatrixElement self, SoState state)"},
	 { "SoModelMatrixElement_matches", _wrap_SoModelMatrixElement_matches, METH_VARARGS, "SoModelMatrixElement_matches(SoModelMatrixElement self, SoElement element) -> SbBool"},
	 { "SoModelMatrixElement_makeIdentity", _wrap_SoModelMatrixElement_makeIdentity, METH_VARARGS, "SoModelMatrixElement_makeIdentity(SoState state, SoNode node)"},
	 { "SoModelMatrixElement_set", _wrap_SoModelMatrixElement_set, METH_VARARGS, "SoModelMatrixElement_set(SoState state, SoNode node)"},
	 { "SoModelMatrixElement_setCullMatrix", _wrap_SoModelMatrixElement_setCullMatrix, METH_VARARGS, "SoModelMatrixElement_setCullMatrix(SoState state, SoNode node)"},
	 { "SoModelMatrixElement_mult", _wrap_SoModelMatrixElement_mult, METH_VARARGS, "SoModelMatrixElement_mult(SoState state, SoNode node)"},
	 { "SoModelMatrixElement_translateBy", _wrap_SoModelMatrixElement_translateBy, METH_VARARGS, "SoModelMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"},
	 { "SoModelMatrixElement_rotateBy", _wrap_SoModelMatrixElement_rotateBy, METH_VARARGS, "SoModelMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"},
	 { "SoModelMatrixElement_scaleBy", _wrap_SoModelMatrixElement_scaleBy, METH_VARARGS, "SoModelMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"},
	 { "SoModelMatrixElement_pushMatrix", _wrap_SoModelMatrixElement_pushMatrix, METH_O, "SoModelMatrixElement_pushMatrix(SoState state) -> SbMatrix"},
	 { "SoModelMatrixElement_popMatrix", _wrap_SoModelMatrixElement_popMatrix, METH_O, "SoModelMatrixElement_popMatrix(SoState state)"},
	 { "SoModelMatrixElement_getCombinedCullMatrix", _wrap_SoModelMatrixElement_getCombinedCullMatrix, METH_O, "SoModelMatrixElement_getCombinedCullMatrix(SoState state) -> SbMatrix"},
	 { "SoModelMatrixElement_get", _wrap_SoModelMatrixElement_get, METH_VARARGS, "\n"
		"SoModelMatrixElement_get(SoState state) -> SbMatrix\n"
		"SoModelMatrixElement_get(SoState state, SbBool & isIdentity) -> SbMatrix\n"
		""},
	 { "SoModelMatrixElement_getModelMatrix", _wrap_SoModelMatrixElement_getModelMatrix, METH_O, "SoModelMatrixElement_getModelMatrix(SoModelMatrixElement self) -> SbMatrix"},
	 { "SoModelMatrixElement_swigregister", SoModelMatrixElement_swigregister, METH_O, NULL},
	 { "SoBBoxModelMatrixElement_getClassTypeId", _wrap_SoBBoxModelMatrixElement_getClassTypeId, METH_NOARGS, "SoBBoxModelMatrixElement_getClassTypeId() -> SoType"},
	 { "SoBBoxModelMatrixElement_getClassStackIndex", _wrap_SoBBoxModelMatrixElement_getClassStackIndex, METH_NOARGS, "SoBBoxModelMatrixElement_getClassStackIndex() -> int"},
	 { "SoBBoxModelMatrixElement_createInstance", _wrap_SoBBoxModelMatrixElement_createInstance, METH_NOARGS, "SoBBoxModelMatrixElement_createInstance() -> void *"},
	 { "SoBBoxModelMatrixElement_initClass", _wrap_SoBBoxModelMatrixElement_initClass, METH_NOARGS, "SoBBoxModelMatrixElement_initClass()"},
	 { "SoBBoxModelMatrixElement_init", _wrap_SoBBoxModelMatrixElement_init, METH_VARARGS, "SoBBoxModelMatrixElement_init(SoBBoxModelMatrixElement self, SoState state)"},
	 { "SoBBoxModelMatrixElement_push", _wrap_SoBBoxModelMatrixElement_push, METH_VARARGS, "SoBBoxModelMatrixElement_push(SoBBoxModelMatrixElement self, SoState state)"},
	 { "SoBBoxModelMatrixElement_reset", _wrap_SoBBoxModelMatrixElement_reset, METH_VARARGS, "SoBBoxModelMatrixElement_reset(SoState state, SoNode node)"},
	 { "SoBBoxModelMatrixElement_pushMatrix", _wrap_SoBBoxModelMatrixElement_pushMatrix, METH_VARARGS, "SoBBoxModelMatrixElement_pushMatrix(SoState state, SbMatrix localmatrix)"},
	 { "SoBBoxModelMatrixElement_popMatrix", _wrap_SoBBoxModelMatrixElement_popMatrix, METH_VARARGS, "SoBBoxModelMatrixElement_popMatrix(SoState state, SbMatrix localmatrix)"},
	 { "SoBBoxModelMatrixElement_swigregister", SoBBoxModelMatrixElement_swigregister, METH_O, NULL},
	 { "SoBumpMapCoordinateElement_getClassTypeId", _wrap_SoBumpMapCoordinateElement_getClassTypeId, METH_NOARGS, "SoBumpMapCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoBumpMapCoordinateElement_getClassStackIndex", _wrap_SoBumpMapCoordinateElement_getClassStackIndex, METH_NOARGS, "SoBumpMapCoordinateElement_getClassStackIndex() -> int"},
	 { "SoBumpMapCoordinateElement_createInstance", _wrap_SoBumpMapCoordinateElement_createInstance, METH_NOARGS, "SoBumpMapCoordinateElement_createInstance() -> void *"},
	 { "SoBumpMapCoordinateElement_initClass", _wrap_SoBumpMapCoordinateElement_initClass, METH_NOARGS, "SoBumpMapCoordinateElement_initClass()"},
	 { "SoBumpMapCoordinateElement_init", _wrap_SoBumpMapCoordinateElement_init, METH_VARARGS, "SoBumpMapCoordinateElement_init(SoBumpMapCoordinateElement self, SoState state)"},
	 { "SoBumpMapCoordinateElement_set", _wrap_SoBumpMapCoordinateElement_set, METH_VARARGS, "SoBumpMapCoordinateElement_set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"},
	 { "SoBumpMapCoordinateElement_getInstance", _wrap_SoBumpMapCoordinateElement_getInstance, METH_O, "SoBumpMapCoordinateElement_getInstance(SoState state) -> SoBumpMapCoordinateElement"},
	 { "SoBumpMapCoordinateElement_getNum", _wrap_SoBumpMapCoordinateElement_getNum, METH_O, "SoBumpMapCoordinateElement_getNum(SoBumpMapCoordinateElement self) -> int32_t"},
	 { "SoBumpMapCoordinateElement_get", _wrap_SoBumpMapCoordinateElement_get, METH_VARARGS, "SoBumpMapCoordinateElement_get(SoBumpMapCoordinateElement self, int const index) -> SbVec2f"},
	 { "SoBumpMapCoordinateElement_getArrayPtr", _wrap_SoBumpMapCoordinateElement_getArrayPtr, METH_O, "SoBumpMapCoordinateElement_getArrayPtr(SoBumpMapCoordinateElement self) -> SbVec2f"},
	 { "SoBumpMapCoordinateElement_swigregister", SoBumpMapCoordinateElement_swigregister, METH_O, NULL},
	 { "SoBumpMapElement_getClassTypeId", _wrap_SoBumpMapElement_getClassTypeId, METH_NOARGS, "SoBumpMapElement_getClassTypeId() -> SoType"},
	 { "SoBumpMapElement_getClassStackIndex", _wrap_SoBumpMapElement_getClassStackIndex, METH_NOARGS, "SoBumpMapElement_getClassStackIndex() -> int"},
	 { "SoBumpMapElement_createInstance", _wrap_SoBumpMapElement_createInstance, METH_NOARGS, "SoBumpMapElement_createInstance() -> void *"},
	 { "SoBumpMapElement_initClass", _wrap_SoBumpMapElement_initClass, METH_NOARGS, "SoBumpMapElement_initClass()"},
	 { "SoBumpMapElement_init", _wrap_SoBumpMapElement_init, METH_VARARGS, "SoBumpMapElement_init(SoBumpMapElement self, SoState state)"},
	 { "SoBumpMapElement_set", _wrap_SoBumpMapElement_set, METH_VARARGS, "SoBumpMapElement_set(SoState state, SoNode node, SoGLImage image)"},
	 { "SoBumpMapElement_get", _wrap_SoBumpMapElement_get, METH_O, "SoBumpMapElement_get(SoState state) -> SoGLImage"},
	 { "SoBumpMapElement_swigregister", SoBumpMapElement_swigregister, METH_O, NULL},
	 { "SoBumpMapMatrixElement_getClassTypeId", _wrap_SoBumpMapMatrixElement_getClassTypeId, METH_NOARGS, "SoBumpMapMatrixElement_getClassTypeId() -> SoType"},
	 { "SoBumpMapMatrixElement_getClassStackIndex", _wrap_SoBumpMapMatrixElement_getClassStackIndex, METH_NOARGS, "SoBumpMapMatrixElement_getClassStackIndex() -> int"},
	 { "SoBumpMapMatrixElement_createInstance", _wrap_SoBumpMapMatrixElement_createInstance, METH_NOARGS, "SoBumpMapMatrixElement_createInstance() -> void *"},
	 { "SoBumpMapMatrixElement_initClass", _wrap_SoBumpMapMatrixElement_initClass, METH_NOARGS, "SoBumpMapMatrixElement_initClass()"},
	 { "SoBumpMapMatrixElement_init", _wrap_SoBumpMapMatrixElement_init, METH_VARARGS, "SoBumpMapMatrixElement_init(SoBumpMapMatrixElement self, SoState state)"},
	 { "SoBumpMapMatrixElement_push", _wrap_SoBumpMapMatrixElement_push, METH_VARARGS, "SoBumpMapMatrixElement_push(SoBumpMapMatrixElement self, SoState state)"},
	 { "SoBumpMapMatrixElement_makeIdentity", _wrap_SoBumpMapMatrixElement_makeIdentity, METH_VARARGS, "SoBumpMapMatrixElement_makeIdentity(SoState state, SoNode node)"},
	 { "SoBumpMapMatrixElement_set", _wrap_SoBumpMapMatrixElement_set, METH_VARARGS, "SoBumpMapMatrixElement_set(SoState state, SoNode node)"},
	 { "SoBumpMapMatrixElement_mult", _wrap_SoBumpMapMatrixElement_mult, METH_VARARGS, "SoBumpMapMatrixElement_mult(SoState state, SoNode node)"},
	 { "SoBumpMapMatrixElement_translateBy", _wrap_SoBumpMapMatrixElement_translateBy, METH_VARARGS, "SoBumpMapMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"},
	 { "SoBumpMapMatrixElement_rotateBy", _wrap_SoBumpMapMatrixElement_rotateBy, METH_VARARGS, "SoBumpMapMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"},
	 { "SoBumpMapMatrixElement_scaleBy", _wrap_SoBumpMapMatrixElement_scaleBy, METH_VARARGS, "SoBumpMapMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"},
	 { "SoBumpMapMatrixElement_get", _wrap_SoBumpMapMatrixElement_get, METH_O, "SoBumpMapMatrixElement_get(SoState state) -> SbMatrix"},
	 { "SoBumpMapMatrixElement_swigregister", SoBumpMapMatrixElement_swigregister, METH_O, NULL},
	 { "SoCacheElement_getClassTypeId", _wrap_SoCacheElement_getClassTypeId, METH_NOARGS, "SoCacheElement_getClassTypeId() -> SoType"},
	 { "SoCacheElement_getClassStackIndex", _wrap_SoCacheElement_getClassStackIndex, METH_NOARGS, "SoCacheElement_getClassStackIndex() -> int"},
	 { "SoCacheElement_createInstance", _wrap_SoCacheElement_createInstance, METH_NOARGS, "SoCacheElement_createInstance() -> void *"},
	 { "SoCacheElement_initClass", _wrap_SoCacheElement_initClass, METH_NOARGS, "SoCacheElement_initClass()"},
	 { "SoCacheElement_init", _wrap_SoCacheElement_init, METH_VARARGS, "SoCacheElement_init(SoCacheElement self, SoState state)"},
	 { "SoCacheElement_push", _wrap_SoCacheElement_push, METH_VARARGS, "SoCacheElement_push(SoCacheElement self, SoState state)"},
	 { "SoCacheElement_pop", _wrap_SoCacheElement_pop, METH_VARARGS, "SoCacheElement_pop(SoCacheElement self, SoState state, SoElement prevTopElement)"},
	 { "SoCacheElement_set", _wrap_SoCacheElement_set, METH_VARARGS, "SoCacheElement_set(SoState state, SoCache cache)"},
	 { "SoCacheElement_getCache", _wrap_SoCacheElement_getCache, METH_O, "SoCacheElement_getCache(SoCacheElement self) -> SoCache"},
	 { "SoCacheElement_anyOpen", _wrap_SoCacheElement_anyOpen, METH_O, "SoCacheElement_anyOpen(SoState state) -> SbBool"},
	 { "SoCacheElement_invalidate", _wrap_SoCacheElement_invalidate, METH_O, "SoCacheElement_invalidate(SoState state)"},
	 { "SoCacheElement_matches", _wrap_SoCacheElement_matches, METH_VARARGS, "SoCacheElement_matches(SoCacheElement self, SoElement element) -> SbBool"},
	 { "SoCacheElement_copyMatchInfo", _wrap_SoCacheElement_copyMatchInfo, METH_O, "SoCacheElement_copyMatchInfo(SoCacheElement self) -> SoElement"},
	 { "SoCacheElement_getNextCacheElement", _wrap_SoCacheElement_getNextCacheElement, METH_O, "SoCacheElement_getNextCacheElement(SoCacheElement self) -> SoCacheElement"},
	 { "SoCacheElement_addElement", _wrap_SoCacheElement_addElement, METH_VARARGS, "SoCacheElement_addElement(SoState state, SoElement element)"},
	 { "SoCacheElement_addCacheDependency", _wrap_SoCacheElement_addCacheDependency, METH_VARARGS, "SoCacheElement_addCacheDependency(SoState state, SoCache cache)"},
	 { "SoCacheElement_setInvalid", _wrap_SoCacheElement_setInvalid, METH_O, "SoCacheElement_setInvalid(SbBool const newvalue) -> SbBool"},
	 { "SoCacheElement_getCurrentCache", _wrap_SoCacheElement_getCurrentCache, METH_O, "SoCacheElement_getCurrentCache(SoState state) -> SoCache"},
	 { "SoCacheElement_swigregister", SoCacheElement_swigregister, METH_O, NULL},
	 { "new_SbPlane", _wrap_new_SbPlane, METH_VARARGS, "\n"
		"SbPlane()\n"
		"SbPlane(SbVec3f normal, float const D)\n"
		"SbPlane(SbVec3f p0, SbVec3f p1, SbVec3f p2)\n"
		"new_SbPlane(SbVec3f normal, SbVec3f point) -> SbPlane\n"
		""},
	 { "SbPlane_offset", _wrap_SbPlane_offset, METH_VARARGS, "SbPlane_offset(SbPlane self, float const d)"},
	 { "SbPlane_transform", _wrap_SbPlane_transform, METH_O, "SbPlane_transform(SbPlane self)"},
	 { "SbPlane_isInHalfSpace", _wrap_SbPlane_isInHalfSpace, METH_VARARGS, "SbPlane_isInHalfSpace(SbPlane self, SbVec3f point) -> SbBool"},
	 { "SbPlane_getDistance", _wrap_SbPlane_getDistance, METH_VARARGS, "SbPlane_getDistance(SbPlane self, SbVec3f point) -> float"},
	 { "SbPlane_getNormal", _wrap_SbPlane_getNormal, METH_O, "SbPlane_getNormal(SbPlane self) -> SbVec3f"},
	 { "SbPlane_getDistanceFromOrigin", _wrap_SbPlane_getDistanceFromOrigin, METH_O, "SbPlane_getDistanceFromOrigin(SbPlane self) -> float"},
	 { "SbPlane_output", _wrap_SbPlane_output, METH_VARARGS, "SbPlane_output(SbPlane self, FILE * file)"},
	 { "SbPlane___eq__", _wrap_SbPlane___eq__, METH_VARARGS, "SbPlane___eq__(SbPlane self, SbPlane u) -> int"},
	 { "SbPlane___ne__", _wrap_SbPlane___ne__, METH_VARARGS, "SbPlane___ne__(SbPlane self, SbPlane u) -> int"},
	 { "SbPlane_intersect", _wrap_SbPlane_intersect, METH_VARARGS, "intersect(SbPlane) -> SbLineintersect(SbPlane) -> SbLine"},
	 { "delete_SbPlane", _wrap_delete_SbPlane, METH_O, "delete_SbPlane(SbPlane self)"},
	 { "SbPlane_swigregister", SbPlane_swigregister, METH_O, NULL},
	 { "SbPlane_swiginit", SbPlane_swiginit, METH_VARARGS, NULL},
	 { "SoClipPlaneElement_getClassTypeId", _wrap_SoClipPlaneElement_getClassTypeId, METH_NOARGS, "SoClipPlaneElement_getClassTypeId() -> SoType"},
	 { "SoClipPlaneElement_getClassStackIndex", _wrap_SoClipPlaneElement_getClassStackIndex, METH_NOARGS, "SoClipPlaneElement_getClassStackIndex() -> int"},
	 { "SoClipPlaneElement_createInstance", _wrap_SoClipPlaneElement_createInstance, METH_NOARGS, "SoClipPlaneElement_createInstance() -> void *"},
	 { "SoClipPlaneElement_initClass", _wrap_SoClipPlaneElement_initClass, METH_NOARGS, "SoClipPlaneElement_initClass()"},
	 { "SoClipPlaneElement_init", _wrap_SoClipPlaneElement_init, METH_VARARGS, "SoClipPlaneElement_init(SoClipPlaneElement self, SoState state)"},
	 { "SoClipPlaneElement_push", _wrap_SoClipPlaneElement_push, METH_VARARGS, "SoClipPlaneElement_push(SoClipPlaneElement self, SoState state)"},
	 { "SoClipPlaneElement_add", _wrap_SoClipPlaneElement_add, METH_VARARGS, "SoClipPlaneElement_add(SoState state, SoNode node, SbPlane plane)"},
	 { "SoClipPlaneElement_getInstance", _wrap_SoClipPlaneElement_getInstance, METH_O, "SoClipPlaneElement_getInstance(SoState state) -> SoClipPlaneElement"},
	 { "SoClipPlaneElement_getNum", _wrap_SoClipPlaneElement_getNum, METH_O, "SoClipPlaneElement_getNum(SoClipPlaneElement self) -> int"},
	 { "SoClipPlaneElement_get", _wrap_SoClipPlaneElement_get, METH_VARARGS, "SoClipPlaneElement_get(SoClipPlaneElement self, int const index, SbBool const inworldspace=1) -> SbPlane"},
	 { "SoClipPlaneElement_swigregister", SoClipPlaneElement_swigregister, METH_O, NULL},
	 { "SoFloatElement_getClassTypeId", _wrap_SoFloatElement_getClassTypeId, METH_NOARGS, "SoFloatElement_getClassTypeId() -> SoType"},
	 { "SoFloatElement_getClassStackIndex", _wrap_SoFloatElement_getClassStackIndex, METH_NOARGS, "SoFloatElement_getClassStackIndex() -> int"},
	 { "SoFloatElement_initClass", _wrap_SoFloatElement_initClass, METH_NOARGS, "SoFloatElement_initClass()"},
	 { "SoFloatElement_init", _wrap_SoFloatElement_init, METH_VARARGS, "SoFloatElement_init(SoFloatElement self, SoState state)"},
	 { "SoFloatElement_matches", _wrap_SoFloatElement_matches, METH_VARARGS, "SoFloatElement_matches(SoFloatElement self, SoElement element) -> SbBool"},
	 { "SoFloatElement_copyMatchInfo", _wrap_SoFloatElement_copyMatchInfo, METH_O, "SoFloatElement_copyMatchInfo(SoFloatElement self) -> SoElement"},
	 { "SoFloatElement_output", _wrap_SoFloatElement_output, METH_VARARGS, "SoFloatElement_output(SoFloatElement self, FILE * file)"},
	 { "SoFloatElement_set", _wrap_SoFloatElement_set, METH_VARARGS, "\n"
		"SoFloatElement_set(int const stackIndex, SoState state, SoNode node, float const value)\n"
		"SoFloatElement_set(int const stackIndex, SoState state, float const value)\n"
		""},
	 { "SoFloatElement_get", _wrap_SoFloatElement_get, METH_VARARGS, "SoFloatElement_get(int const stackIndex, SoState state) -> float"},
	 { "SoFloatElement_setElt", _wrap_SoFloatElement_setElt, METH_VARARGS, "SoFloatElement_setElt(SoFloatElement self, float value)"},
	 { "SoFloatElement_swigregister", SoFloatElement_swigregister, METH_O, NULL},
	 { "SoComplexityElement_getClassTypeId", _wrap_SoComplexityElement_getClassTypeId, METH_NOARGS, "SoComplexityElement_getClassTypeId() -> SoType"},
	 { "SoComplexityElement_getClassStackIndex", _wrap_SoComplexityElement_getClassStackIndex, METH_NOARGS, "SoComplexityElement_getClassStackIndex() -> int"},
	 { "SoComplexityElement_createInstance", _wrap_SoComplexityElement_createInstance, METH_NOARGS, "SoComplexityElement_createInstance() -> void *"},
	 { "SoComplexityElement_initClass", _wrap_SoComplexityElement_initClass, METH_NOARGS, "SoComplexityElement_initClass()"},
	 { "SoComplexityElement_init", _wrap_SoComplexityElement_init, METH_VARARGS, "SoComplexityElement_init(SoComplexityElement self, SoState state)"},
	 { "SoComplexityElement_set", _wrap_SoComplexityElement_set, METH_VARARGS, "\n"
		"SoComplexityElement_set(SoState state, SoNode node, float const complexity)\n"
		"SoComplexityElement_set(SoState state, float const complexity)\n"
		""},
	 { "SoComplexityElement_get", _wrap_SoComplexityElement_get, METH_O, "SoComplexityElement_get(SoState state) -> float"},
	 { "SoComplexityElement_getDefault", _wrap_SoComplexityElement_getDefault, METH_NOARGS, "SoComplexityElement_getDefault() -> float"},
	 { "SoComplexityElement_swigregister", SoComplexityElement_swigregister, METH_O, NULL},
	 { "SoCoordinateElement_getClassTypeId", _wrap_SoCoordinateElement_getClassTypeId, METH_NOARGS, "SoCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoCoordinateElement_getClassStackIndex", _wrap_SoCoordinateElement_getClassStackIndex, METH_NOARGS, "SoCoordinateElement_getClassStackIndex() -> int"},
	 { "SoCoordinateElement_createInstance", _wrap_SoCoordinateElement_createInstance, METH_NOARGS, "SoCoordinateElement_createInstance() -> void *"},
	 { "SoCoordinateElement_initClass", _wrap_SoCoordinateElement_initClass, METH_NOARGS, "SoCoordinateElement_initClass()"},
	 { "SoCoordinateElement_init", _wrap_SoCoordinateElement_init, METH_VARARGS, "SoCoordinateElement_init(SoCoordinateElement self, SoState state)"},
	 { "SoCoordinateElement_set3", _wrap_SoCoordinateElement_set3, METH_VARARGS, "SoCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"},
	 { "SoCoordinateElement_set4", _wrap_SoCoordinateElement_set4, METH_VARARGS, "SoCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"},
	 { "SoCoordinateElement_getInstance", _wrap_SoCoordinateElement_getInstance, METH_O, "SoCoordinateElement_getInstance(SoState state) -> SoCoordinateElement"},
	 { "SoCoordinateElement_getNum", _wrap_SoCoordinateElement_getNum, METH_O, "SoCoordinateElement_getNum(SoCoordinateElement self) -> int32_t"},
	 { "SoCoordinateElement_is3D", _wrap_SoCoordinateElement_is3D, METH_O, "SoCoordinateElement_is3D(SoCoordinateElement self) -> SbBool"},
	 { "SoCoordinateElement_get3", _wrap_SoCoordinateElement_get3, METH_VARARGS, "SoCoordinateElement_get3(SoCoordinateElement self, int const index) -> SbVec3f"},
	 { "SoCoordinateElement_get4", _wrap_SoCoordinateElement_get4, METH_VARARGS, "SoCoordinateElement_get4(SoCoordinateElement self, int const index) -> SbVec4f"},
	 { "SoCoordinateElement_getArrayPtr3", _wrap_SoCoordinateElement_getArrayPtr3, METH_O, "SoCoordinateElement_getArrayPtr3(SoCoordinateElement self) -> SbVec3f"},
	 { "SoCoordinateElement_getArrayPtr4", _wrap_SoCoordinateElement_getArrayPtr4, METH_O, "SoCoordinateElement_getArrayPtr4(SoCoordinateElement self) -> SbVec4f"},
	 { "SoCoordinateElement_getDefault3", _wrap_SoCoordinateElement_getDefault3, METH_NOARGS, "SoCoordinateElement_getDefault3() -> SbVec3f"},
	 { "SoCoordinateElement_getDefault4", _wrap_SoCoordinateElement_getDefault4, METH_NOARGS, "SoCoordinateElement_getDefault4() -> SbVec4f"},
	 { "SoCoordinateElement_output", _wrap_SoCoordinateElement_output, METH_VARARGS, "SoCoordinateElement_output(SoCoordinateElement self, FILE * file)"},
	 { "SoCoordinateElement_swigregister", SoCoordinateElement_swigregister, METH_O, NULL},
	 { "SoCreaseAngleElement_getClassTypeId", _wrap_SoCreaseAngleElement_getClassTypeId, METH_NOARGS, "SoCreaseAngleElement_getClassTypeId() -> SoType"},
	 { "SoCreaseAngleElement_getClassStackIndex", _wrap_SoCreaseAngleElement_getClassStackIndex, METH_NOARGS, "SoCreaseAngleElement_getClassStackIndex() -> int"},
	 { "SoCreaseAngleElement_createInstance", _wrap_SoCreaseAngleElement_createInstance, METH_NOARGS, "SoCreaseAngleElement_createInstance() -> void *"},
	 { "SoCreaseAngleElement_initClass", _wrap_SoCreaseAngleElement_initClass, METH_NOARGS, "SoCreaseAngleElement_initClass()"},
	 { "SoCreaseAngleElement_init", _wrap_SoCreaseAngleElement_init, METH_VARARGS, "SoCreaseAngleElement_init(SoCreaseAngleElement self, SoState state)"},
	 { "SoCreaseAngleElement_set", _wrap_SoCreaseAngleElement_set, METH_VARARGS, "\n"
		"SoCreaseAngleElement_set(SoState state, SoNode node, float const complexity)\n"
		"SoCreaseAngleElement_set(SoState state, float const complexity)\n"
		""},
	 { "SoCreaseAngleElement_get", _wrap_SoCreaseAngleElement_get, METH_VARARGS, "\n"
		"SoCreaseAngleElement_get(SoState state) -> float\n"
		"SoCreaseAngleElement_get(SoState state, SbBool const isvrml1) -> float\n"
		""},
	 { "SoCreaseAngleElement_getDefault", _wrap_SoCreaseAngleElement_getDefault, METH_VARARGS, "\n"
		"SoCreaseAngleElement_getDefault() -> float\n"
		"SoCreaseAngleElement_getDefault(SbBool const isvrml1) -> float\n"
		""},
	 { "SoCreaseAngleElement_swigregister", SoCreaseAngleElement_swigregister, METH_O, NULL},
	 { "SoCullElement_getClassTypeId", _wrap_SoCullElement_getClassTypeId, METH_NOARGS, "SoCullElement_getClassTypeId() -> SoType"},
	 { "SoCullElement_getClassStackIndex", _wrap_SoCullElement_getClassStackIndex, METH_NOARGS, "SoCullElement_getClassStackIndex() -> int"},
	 { "SoCullElement_createInstance", _wrap_SoCullElement_createInstance, METH_NOARGS, "SoCullElement_createInstance() -> void *"},
	 { "SoCullElement_initClass", _wrap_SoCullElement_initClass, METH_NOARGS, "SoCullElement_initClass()"},
	 { "SoCullElement_init", _wrap_SoCullElement_init, METH_VARARGS, "SoCullElement_init(SoCullElement self, SoState state)"},
	 { "SoCullElement_push", _wrap_SoCullElement_push, METH_VARARGS, "SoCullElement_push(SoCullElement self, SoState state)"},
	 { "SoCullElement_setViewVolume", _wrap_SoCullElement_setViewVolume, METH_VARARGS, "SoCullElement_setViewVolume(SoState state, SbViewVolume vv)"},
	 { "SoCullElement_addPlane", _wrap_SoCullElement_addPlane, METH_VARARGS, "SoCullElement_addPlane(SoState state, SbPlane newplane)"},
	 { "SoCullElement_cullBox", _wrap_SoCullElement_cullBox, METH_VARARGS, "SoCullElement_cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"},
	 { "SoCullElement_cullTest", _wrap_SoCullElement_cullTest, METH_VARARGS, "SoCullElement_cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"},
	 { "SoCullElement_completelyInside", _wrap_SoCullElement_completelyInside, METH_O, "SoCullElement_completelyInside(SoState state) -> SbBool"},
	 { "SoCullElement_matches", _wrap_SoCullElement_matches, METH_VARARGS, "SoCullElement_matches(SoCullElement self, SoElement elt) -> SbBool"},
	 { "SoCullElement_copyMatchInfo", _wrap_SoCullElement_copyMatchInfo, METH_O, "SoCullElement_copyMatchInfo(SoCullElement self) -> SoElement"},
	 { "SoCullElement_swigregister", SoCullElement_swigregister, METH_O, NULL},
	 { "SoDecimationPercentageElement_getClassTypeId", _wrap_SoDecimationPercentageElement_getClassTypeId, METH_NOARGS, "SoDecimationPercentageElement_getClassTypeId() -> SoType"},
	 { "SoDecimationPercentageElement_getClassStackIndex", _wrap_SoDecimationPercentageElement_getClassStackIndex, METH_NOARGS, "SoDecimationPercentageElement_getClassStackIndex() -> int"},
	 { "SoDecimationPercentageElement_createInstance", _wrap_SoDecimationPercentageElement_createInstance, METH_NOARGS, "SoDecimationPercentageElement_createInstance() -> void *"},
	 { "SoDecimationPercentageElement_initClass", _wrap_SoDecimationPercentageElement_initClass, METH_NOARGS, "SoDecimationPercentageElement_initClass()"},
	 { "SoDecimationPercentageElement_init", _wrap_SoDecimationPercentageElement_init, METH_VARARGS, "SoDecimationPercentageElement_init(SoDecimationPercentageElement self, SoState state)"},
	 { "SoDecimationPercentageElement_set", _wrap_SoDecimationPercentageElement_set, METH_VARARGS, "\n"
		"SoDecimationPercentageElement_set(SoState state, SoNode node, float const complexity)\n"
		"SoDecimationPercentageElement_set(SoState state, float const complexity)\n"
		""},
	 { "SoDecimationPercentageElement_get", _wrap_SoDecimationPercentageElement_get, METH_O, "SoDecimationPercentageElement_get(SoState state) -> float"},
	 { "SoDecimationPercentageElement_getDefault", _wrap_SoDecimationPercentageElement_getDefault, METH_NOARGS, "SoDecimationPercentageElement_getDefault() -> float"},
	 { "SoDecimationPercentageElement_swigregister", SoDecimationPercentageElement_swigregister, METH_O, NULL},
	 { "SoDiffuseColorElement_getClassTypeId", _wrap_SoDiffuseColorElement_getClassTypeId, METH_NOARGS, "SoDiffuseColorElement_getClassTypeId() -> SoType"},
	 { "SoDiffuseColorElement_getClassStackIndex", _wrap_SoDiffuseColorElement_getClassStackIndex, METH_NOARGS, "SoDiffuseColorElement_getClassStackIndex() -> int"},
	 { "SoDiffuseColorElement_createInstance", _wrap_SoDiffuseColorElement_createInstance, METH_NOARGS, "SoDiffuseColorElement_createInstance() -> void *"},
	 { "SoDiffuseColorElement_initClass", _wrap_SoDiffuseColorElement_initClass, METH_NOARGS, "SoDiffuseColorElement_initClass()"},
	 { "SoDiffuseColorElement_init", _wrap_SoDiffuseColorElement_init, METH_VARARGS, "SoDiffuseColorElement_init(SoDiffuseColorElement self, SoState state)"},
	 { "SoDiffuseColorElement_set", _wrap_SoDiffuseColorElement_set, METH_VARARGS, "SoDiffuseColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"},
	 { "SoDiffuseColorElement_getInstance", _wrap_SoDiffuseColorElement_getInstance, METH_O, "SoDiffuseColorElement_getInstance(SoState state) -> SoDiffuseColorElement"},
	 { "SoDiffuseColorElement_getNum", _wrap_SoDiffuseColorElement_getNum, METH_O, "SoDiffuseColorElement_getNum(SoDiffuseColorElement self) -> int32_t"},
	 { "SoDiffuseColorElement_get", _wrap_SoDiffuseColorElement_get, METH_VARARGS, "SoDiffuseColorElement_get(SoDiffuseColorElement self, int const index) -> SbColor"},
	 { "SoDiffuseColorElement_isPacked", _wrap_SoDiffuseColorElement_isPacked, METH_O, "SoDiffuseColorElement_isPacked(SoDiffuseColorElement self) -> SbBool"},
	 { "SoDiffuseColorElement_hasPackedTransparency", _wrap_SoDiffuseColorElement_hasPackedTransparency, METH_O, "SoDiffuseColorElement_hasPackedTransparency(SoDiffuseColorElement self) -> SbBool"},
	 { "SoDiffuseColorElement_getColorArrayPtr", _wrap_SoDiffuseColorElement_getColorArrayPtr, METH_O, "SoDiffuseColorElement_getColorArrayPtr(SoDiffuseColorElement self) -> SbColor"},
	 { "SoDiffuseColorElement_getPackedArrayPtr", _wrap_SoDiffuseColorElement_getPackedArrayPtr, METH_O, "SoDiffuseColorElement_getPackedArrayPtr(SoDiffuseColorElement self) -> uint32_t const *"},
	 { "SoDiffuseColorElement_swigregister", SoDiffuseColorElement_swigregister, METH_O, NULL},
	 { "SoGLClipPlaneElement_getClassTypeId", _wrap_SoGLClipPlaneElement_getClassTypeId, METH_NOARGS, "SoGLClipPlaneElement_getClassTypeId() -> SoType"},
	 { "SoGLClipPlaneElement_getClassStackIndex", _wrap_SoGLClipPlaneElement_getClassStackIndex, METH_NOARGS, "SoGLClipPlaneElement_getClassStackIndex() -> int"},
	 { "SoGLClipPlaneElement_createInstance", _wrap_SoGLClipPlaneElement_createInstance, METH_NOARGS, "SoGLClipPlaneElement_createInstance() -> void *"},
	 { "SoGLClipPlaneElement_initClass", _wrap_SoGLClipPlaneElement_initClass, METH_NOARGS, "SoGLClipPlaneElement_initClass()"},
	 { "SoGLClipPlaneElement_init", _wrap_SoGLClipPlaneElement_init, METH_VARARGS, "SoGLClipPlaneElement_init(SoGLClipPlaneElement self, SoState state)"},
	 { "SoGLClipPlaneElement_pop", _wrap_SoGLClipPlaneElement_pop, METH_VARARGS, "SoGLClipPlaneElement_pop(SoGLClipPlaneElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLClipPlaneElement_getMaxGLPlanes", _wrap_SoGLClipPlaneElement_getMaxGLPlanes, METH_NOARGS, "SoGLClipPlaneElement_getMaxGLPlanes() -> int"},
	 { "SoGLClipPlaneElement_swigregister", SoGLClipPlaneElement_swigregister, METH_O, NULL},
	 { "SoLightElement_getClassTypeId", _wrap_SoLightElement_getClassTypeId, METH_NOARGS, "SoLightElement_getClassTypeId() -> SoType"},
	 { "SoLightElement_getClassStackIndex", _wrap_SoLightElement_getClassStackIndex, METH_NOARGS, "SoLightElement_getClassStackIndex() -> int"},
	 { "SoLightElement_createInstance", _wrap_SoLightElement_createInstance, METH_NOARGS, "SoLightElement_createInstance() -> void *"},
	 { "SoLightElement_initClass", _wrap_SoLightElement_initClass, METH_NOARGS, "SoLightElement_initClass()"},
	 { "SoLightElement_init", _wrap_SoLightElement_init, METH_VARARGS, "SoLightElement_init(SoLightElement self, SoState state)"},
	 { "SoLightElement_push", _wrap_SoLightElement_push, METH_VARARGS, "SoLightElement_push(SoLightElement self, SoState state)"},
	 { "SoLightElement_add", _wrap_SoLightElement_add, METH_VARARGS, "SoLightElement_add(SoState state, SoLight light)"},
	 { "SoLightElement_getLights", _wrap_SoLightElement_getLights, METH_O, "SoLightElement_getLights(SoState state) -> SoNodeList"},
	 { "SoLightElement_getMatrix", _wrap_SoLightElement_getMatrix, METH_VARARGS, "SoLightElement_getMatrix(SoState state, int const index) -> SbMatrix"},
	 { "SoLightElement_swigregister", SoLightElement_swigregister, METH_O, NULL},
	 { "SoGLModelMatrixElement_getClassTypeId", _wrap_SoGLModelMatrixElement_getClassTypeId, METH_NOARGS, "SoGLModelMatrixElement_getClassTypeId() -> SoType"},
	 { "SoGLModelMatrixElement_getClassStackIndex", _wrap_SoGLModelMatrixElement_getClassStackIndex, METH_NOARGS, "SoGLModelMatrixElement_getClassStackIndex() -> int"},
	 { "SoGLModelMatrixElement_createInstance", _wrap_SoGLModelMatrixElement_createInstance, METH_NOARGS, "SoGLModelMatrixElement_createInstance() -> void *"},
	 { "SoGLModelMatrixElement_initClass", _wrap_SoGLModelMatrixElement_initClass, METH_NOARGS, "SoGLModelMatrixElement_initClass()"},
	 { "SoGLModelMatrixElement_init", _wrap_SoGLModelMatrixElement_init, METH_VARARGS, "SoGLModelMatrixElement_init(SoGLModelMatrixElement self, SoState state)"},
	 { "SoGLModelMatrixElement_push", _wrap_SoGLModelMatrixElement_push, METH_VARARGS, "SoGLModelMatrixElement_push(SoGLModelMatrixElement self, SoState state)"},
	 { "SoGLModelMatrixElement_pop", _wrap_SoGLModelMatrixElement_pop, METH_VARARGS, "SoGLModelMatrixElement_pop(SoGLModelMatrixElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLModelMatrixElement_swigregister", SoGLModelMatrixElement_swigregister, METH_O, NULL},
	 { "SoProfileElement_getClassTypeId", _wrap_SoProfileElement_getClassTypeId, METH_NOARGS, "SoProfileElement_getClassTypeId() -> SoType"},
	 { "SoProfileElement_getClassStackIndex", _wrap_SoProfileElement_getClassStackIndex, METH_NOARGS, "SoProfileElement_getClassStackIndex() -> int"},
	 { "SoProfileElement_createInstance", _wrap_SoProfileElement_createInstance, METH_NOARGS, "SoProfileElement_createInstance() -> void *"},
	 { "SoProfileElement_initClass", _wrap_SoProfileElement_initClass, METH_NOARGS, "SoProfileElement_initClass()"},
	 { "SoProfileElement_init", _wrap_SoProfileElement_init, METH_VARARGS, "SoProfileElement_init(SoProfileElement self, SoState state)"},
	 { "SoProfileElement_push", _wrap_SoProfileElement_push, METH_VARARGS, "SoProfileElement_push(SoProfileElement self, SoState state)"},
	 { "SoProfileElement_add", _wrap_SoProfileElement_add, METH_VARARGS, "SoProfileElement_add(SoState state, SoProfile profile)"},
	 { "SoProfileElement_get", _wrap_SoProfileElement_get, METH_O, "SoProfileElement_get(SoState state) -> SoNodeList"},
	 { "SoProfileElement_swigregister", SoProfileElement_swigregister, METH_O, NULL},
	 { "SoMultiTextureMatrixElement_getClassTypeId", _wrap_SoMultiTextureMatrixElement_getClassTypeId, METH_NOARGS, "SoMultiTextureMatrixElement_getClassTypeId() -> SoType"},
	 { "SoMultiTextureMatrixElement_getClassStackIndex", _wrap_SoMultiTextureMatrixElement_getClassStackIndex, METH_NOARGS, "SoMultiTextureMatrixElement_getClassStackIndex() -> int"},
	 { "SoMultiTextureMatrixElement_createInstance", _wrap_SoMultiTextureMatrixElement_createInstance, METH_NOARGS, "SoMultiTextureMatrixElement_createInstance() -> void *"},
	 { "SoMultiTextureMatrixElement_initClass", _wrap_SoMultiTextureMatrixElement_initClass, METH_NOARGS, "SoMultiTextureMatrixElement_initClass()"},
	 { "SoMultiTextureMatrixElement_init", _wrap_SoMultiTextureMatrixElement_init, METH_VARARGS, "SoMultiTextureMatrixElement_init(SoMultiTextureMatrixElement self, SoState state)"},
	 { "SoMultiTextureMatrixElement_push", _wrap_SoMultiTextureMatrixElement_push, METH_VARARGS, "SoMultiTextureMatrixElement_push(SoMultiTextureMatrixElement self, SoState state)"},
	 { "SoMultiTextureMatrixElement_get", _wrap_SoMultiTextureMatrixElement_get, METH_VARARGS, "SoMultiTextureMatrixElement_get(SoState state, int const unit=0) -> SbMatrix"},
	 { "SoMultiTextureMatrixElement_makeIdentity", _wrap_SoMultiTextureMatrixElement_makeIdentity, METH_VARARGS, "SoMultiTextureMatrixElement_makeIdentity(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureMatrixElement_set", _wrap_SoMultiTextureMatrixElement_set, METH_VARARGS, "\n"
		"SoMultiTextureMatrixElement_set(SoState state, SoNode node, int const unit)\n"
		"SoMultiTextureMatrixElement_set(SoState state, SoNode node)\n"
		""},
	 { "SoMultiTextureMatrixElement_mult", _wrap_SoMultiTextureMatrixElement_mult, METH_VARARGS, "\n"
		"SoMultiTextureMatrixElement_mult(SoState state, SoNode node, int const unit)\n"
		"SoMultiTextureMatrixElement_mult(SoState state, SoNode node)\n"
		""},
	 { "SoMultiTextureMatrixElement_translateBy", _wrap_SoMultiTextureMatrixElement_translateBy, METH_VARARGS, "SoMultiTextureMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"},
	 { "SoMultiTextureMatrixElement_rotateBy", _wrap_SoMultiTextureMatrixElement_rotateBy, METH_VARARGS, "SoMultiTextureMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"},
	 { "SoMultiTextureMatrixElement_scaleBy", _wrap_SoMultiTextureMatrixElement_scaleBy, METH_VARARGS, "SoMultiTextureMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"},
	 { "SoMultiTextureMatrixElement_swigregister", SoMultiTextureMatrixElement_swigregister, METH_O, NULL},
	 { "SoGLMultiTextureMatrixElement_getClassTypeId", _wrap_SoGLMultiTextureMatrixElement_getClassTypeId, METH_NOARGS, "SoGLMultiTextureMatrixElement_getClassTypeId() -> SoType"},
	 { "SoGLMultiTextureMatrixElement_getClassStackIndex", _wrap_SoGLMultiTextureMatrixElement_getClassStackIndex, METH_NOARGS, "SoGLMultiTextureMatrixElement_getClassStackIndex() -> int"},
	 { "SoGLMultiTextureMatrixElement_createInstance", _wrap_SoGLMultiTextureMatrixElement_createInstance, METH_NOARGS, "SoGLMultiTextureMatrixElement_createInstance() -> void *"},
	 { "SoGLMultiTextureMatrixElement_initClass", _wrap_SoGLMultiTextureMatrixElement_initClass, METH_NOARGS, "SoGLMultiTextureMatrixElement_initClass()"},
	 { "SoGLMultiTextureMatrixElement_init", _wrap_SoGLMultiTextureMatrixElement_init, METH_VARARGS, "SoGLMultiTextureMatrixElement_init(SoGLMultiTextureMatrixElement self, SoState state)"},
	 { "SoGLMultiTextureMatrixElement_push", _wrap_SoGLMultiTextureMatrixElement_push, METH_VARARGS, "SoGLMultiTextureMatrixElement_push(SoGLMultiTextureMatrixElement self, SoState state)"},
	 { "SoGLMultiTextureMatrixElement_pop", _wrap_SoGLMultiTextureMatrixElement_pop, METH_VARARGS, "SoGLMultiTextureMatrixElement_pop(SoGLMultiTextureMatrixElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLMultiTextureMatrixElement_multElt", _wrap_SoGLMultiTextureMatrixElement_multElt, METH_VARARGS, "SoGLMultiTextureMatrixElement_multElt(SoGLMultiTextureMatrixElement self, int const unit)"},
	 { "SoGLMultiTextureMatrixElement_setElt", _wrap_SoGLMultiTextureMatrixElement_setElt, METH_VARARGS, "SoGLMultiTextureMatrixElement_setElt(SoGLMultiTextureMatrixElement self, int const unit)"},
	 { "SoGLMultiTextureMatrixElement_swigregister", SoGLMultiTextureMatrixElement_swigregister, METH_O, NULL},
	 { "SoGLDrawStyleElement_getClassTypeId", _wrap_SoGLDrawStyleElement_getClassTypeId, METH_NOARGS, "SoGLDrawStyleElement_getClassTypeId() -> SoType"},
	 { "SoGLDrawStyleElement_getClassStackIndex", _wrap_SoGLDrawStyleElement_getClassStackIndex, METH_NOARGS, "SoGLDrawStyleElement_getClassStackIndex() -> int"},
	 { "SoGLDrawStyleElement_createInstance", _wrap_SoGLDrawStyleElement_createInstance, METH_NOARGS, "SoGLDrawStyleElement_createInstance() -> void *"},
	 { "SoGLDrawStyleElement_initClass", _wrap_SoGLDrawStyleElement_initClass, METH_NOARGS, "SoGLDrawStyleElement_initClass()"},
	 { "SoGLDrawStyleElement_init", _wrap_SoGLDrawStyleElement_init, METH_VARARGS, "SoGLDrawStyleElement_init(SoGLDrawStyleElement self, SoState state)"},
	 { "SoGLDrawStyleElement_push", _wrap_SoGLDrawStyleElement_push, METH_VARARGS, "SoGLDrawStyleElement_push(SoGLDrawStyleElement self, SoState state)"},
	 { "SoGLDrawStyleElement_pop", _wrap_SoGLDrawStyleElement_pop, METH_VARARGS, "SoGLDrawStyleElement_pop(SoGLDrawStyleElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLDrawStyleElement_swigregister", SoGLDrawStyleElement_swigregister, METH_O, NULL},
	 { "SoGLLightIdElement_getClassTypeId", _wrap_SoGLLightIdElement_getClassTypeId, METH_NOARGS, "SoGLLightIdElement_getClassTypeId() -> SoType"},
	 { "SoGLLightIdElement_getClassStackIndex", _wrap_SoGLLightIdElement_getClassStackIndex, METH_NOARGS, "SoGLLightIdElement_getClassStackIndex() -> int"},
	 { "SoGLLightIdElement_createInstance", _wrap_SoGLLightIdElement_createInstance, METH_NOARGS, "SoGLLightIdElement_createInstance() -> void *"},
	 { "SoGLLightIdElement_initClass", _wrap_SoGLLightIdElement_initClass, METH_NOARGS, "SoGLLightIdElement_initClass()"},
	 { "SoGLLightIdElement_init", _wrap_SoGLLightIdElement_init, METH_VARARGS, "SoGLLightIdElement_init(SoGLLightIdElement self, SoState state)"},
	 { "SoGLLightIdElement_push", _wrap_SoGLLightIdElement_push, METH_VARARGS, "SoGLLightIdElement_push(SoGLLightIdElement self, SoState state)"},
	 { "SoGLLightIdElement_pop", _wrap_SoGLLightIdElement_pop, METH_VARARGS, "SoGLLightIdElement_pop(SoGLLightIdElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLLightIdElement_increment", _wrap_SoGLLightIdElement_increment, METH_VARARGS, "\n"
		"SoGLLightIdElement_increment(SoState state, SoNode node) -> int32_t\n"
		"SoGLLightIdElement_increment(SoState state) -> int32_t\n"
		""},
	 { "SoGLLightIdElement_get", _wrap_SoGLLightIdElement_get, METH_O, "SoGLLightIdElement_get(SoState state) -> int32_t"},
	 { "SoGLLightIdElement_getDefault", _wrap_SoGLLightIdElement_getDefault, METH_NOARGS, "SoGLLightIdElement_getDefault() -> int32_t"},
	 { "SoGLLightIdElement_getMaxGLSources", _wrap_SoGLLightIdElement_getMaxGLSources, METH_NOARGS, "SoGLLightIdElement_getMaxGLSources() -> int32_t"},
	 { "SoGLLightIdElement_swigregister", SoGLLightIdElement_swigregister, METH_O, NULL},
	 { "SoMultiTextureEnabledElement_getClassTypeId", _wrap_SoMultiTextureEnabledElement_getClassTypeId, METH_NOARGS, "SoMultiTextureEnabledElement_getClassTypeId() -> SoType"},
	 { "SoMultiTextureEnabledElement_getClassStackIndex", _wrap_SoMultiTextureEnabledElement_getClassStackIndex, METH_NOARGS, "SoMultiTextureEnabledElement_getClassStackIndex() -> int"},
	 { "SoMultiTextureEnabledElement_createInstance", _wrap_SoMultiTextureEnabledElement_createInstance, METH_NOARGS, "SoMultiTextureEnabledElement_createInstance() -> void *"},
	 { "SoMultiTextureEnabledElement_initClass", _wrap_SoMultiTextureEnabledElement_initClass, METH_NOARGS, "SoMultiTextureEnabledElement_initClass()"},
	 { "SoMultiTextureEnabledElement_init", _wrap_SoMultiTextureEnabledElement_init, METH_VARARGS, "SoMultiTextureEnabledElement_init(SoMultiTextureEnabledElement self, SoState state)"},
	 { "SoMultiTextureEnabledElement_get", _wrap_SoMultiTextureEnabledElement_get, METH_VARARGS, "SoMultiTextureEnabledElement_get(SoState state, int const unit=0) -> SbBool"},
	 { "SoMultiTextureEnabledElement_setElt", _wrap_SoMultiTextureEnabledElement_setElt, METH_VARARGS, "SoMultiTextureEnabledElement_setElt(SoMultiTextureEnabledElement self, int const unit, int const mode)"},
	 { "SoMultiTextureEnabledElement_push", _wrap_SoMultiTextureEnabledElement_push, METH_VARARGS, "SoMultiTextureEnabledElement_push(SoMultiTextureEnabledElement self, SoState state)"},
	 { "SoMultiTextureEnabledElement_matches", _wrap_SoMultiTextureEnabledElement_matches, METH_VARARGS, "SoMultiTextureEnabledElement_matches(SoMultiTextureEnabledElement self, SoElement elem) -> SbBool"},
	 { "SoMultiTextureEnabledElement_copyMatchInfo", _wrap_SoMultiTextureEnabledElement_copyMatchInfo, METH_O, "SoMultiTextureEnabledElement_copyMatchInfo(SoMultiTextureEnabledElement self) -> SoElement"},
	 { "SoMultiTextureEnabledElement_getEnabledUnits", _wrap_SoMultiTextureEnabledElement_getEnabledUnits, METH_VARARGS, "SoMultiTextureEnabledElement_getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"},
	 { "SoMultiTextureEnabledElement_getActiveUnits", _wrap_SoMultiTextureEnabledElement_getActiveUnits, METH_VARARGS, "SoMultiTextureEnabledElement_getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"},
	 { "SoMultiTextureEnabledElement_enableRectangle", _wrap_SoMultiTextureEnabledElement_enableRectangle, METH_VARARGS, "SoMultiTextureEnabledElement_enableRectangle(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureEnabledElement_enableCubeMap", _wrap_SoMultiTextureEnabledElement_enableCubeMap, METH_VARARGS, "SoMultiTextureEnabledElement_enableCubeMap(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureEnabledElement_enableTexture3", _wrap_SoMultiTextureEnabledElement_enableTexture3, METH_VARARGS, "SoMultiTextureEnabledElement_enableTexture3(SoState state, SoNode node, int const unit=0)"},
	 { "SoMultiTextureEnabledElement_getMode", _wrap_SoMultiTextureEnabledElement_getMode, METH_VARARGS, "SoMultiTextureEnabledElement_getMode(SoState state, int const unit=0) -> SoMultiTextureEnabledElement::Mode"},
	 { "SoMultiTextureEnabledElement_disableAll", _wrap_SoMultiTextureEnabledElement_disableAll, METH_O, "SoMultiTextureEnabledElement_disableAll(SoState state)"},
	 { "SoMultiTextureEnabledElement_set", _wrap_SoMultiTextureEnabledElement_set, METH_VARARGS, "\n"
		"SoMultiTextureEnabledElement_set(SoState state, SoNode node, int const unit, SbBool const enabled)\n"
		"SoMultiTextureEnabledElement_set(SoState state, SbBool const enabled)\n"
		"SoMultiTextureEnabledElement_set(SoState state, SoNode node, SbBool const enabled)\n"
		""},
	 { "SoMultiTextureEnabledElement_swigregister", SoMultiTextureEnabledElement_swigregister, METH_O, NULL},
	 { "SoGLMultiTextureEnabledElement_getClassTypeId", _wrap_SoGLMultiTextureEnabledElement_getClassTypeId, METH_NOARGS, "SoGLMultiTextureEnabledElement_getClassTypeId() -> SoType"},
	 { "SoGLMultiTextureEnabledElement_getClassStackIndex", _wrap_SoGLMultiTextureEnabledElement_getClassStackIndex, METH_NOARGS, "SoGLMultiTextureEnabledElement_getClassStackIndex() -> int"},
	 { "SoGLMultiTextureEnabledElement_createInstance", _wrap_SoGLMultiTextureEnabledElement_createInstance, METH_NOARGS, "SoGLMultiTextureEnabledElement_createInstance() -> void *"},
	 { "SoGLMultiTextureEnabledElement_initClass", _wrap_SoGLMultiTextureEnabledElement_initClass, METH_NOARGS, "SoGLMultiTextureEnabledElement_initClass()"},
	 { "SoGLMultiTextureEnabledElement_init", _wrap_SoGLMultiTextureEnabledElement_init, METH_VARARGS, "SoGLMultiTextureEnabledElement_init(SoGLMultiTextureEnabledElement self, SoState state)"},
	 { "SoGLMultiTextureEnabledElement_push", _wrap_SoGLMultiTextureEnabledElement_push, METH_VARARGS, "SoGLMultiTextureEnabledElement_push(SoGLMultiTextureEnabledElement self, SoState state)"},
	 { "SoGLMultiTextureEnabledElement_pop", _wrap_SoGLMultiTextureEnabledElement_pop, METH_VARARGS, "SoGLMultiTextureEnabledElement_pop(SoGLMultiTextureEnabledElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLMultiTextureEnabledElement_setElt", _wrap_SoGLMultiTextureEnabledElement_setElt, METH_VARARGS, "SoGLMultiTextureEnabledElement_setElt(SoGLMultiTextureEnabledElement self, int const unit, int const mode)"},
	 { "SoGLMultiTextureEnabledElement_swigregister", SoGLMultiTextureEnabledElement_swigregister, METH_O, NULL},
	 { "SoLinePatternElement_getClassTypeId", _wrap_SoLinePatternElement_getClassTypeId, METH_NOARGS, "SoLinePatternElement_getClassTypeId() -> SoType"},
	 { "SoLinePatternElement_getClassStackIndex", _wrap_SoLinePatternElement_getClassStackIndex, METH_NOARGS, "SoLinePatternElement_getClassStackIndex() -> int"},
	 { "SoLinePatternElement_createInstance", _wrap_SoLinePatternElement_createInstance, METH_NOARGS, "SoLinePatternElement_createInstance() -> void *"},
	 { "SoLinePatternElement_initClass", _wrap_SoLinePatternElement_initClass, METH_NOARGS, "SoLinePatternElement_initClass()"},
	 { "SoLinePatternElement_init", _wrap_SoLinePatternElement_init, METH_VARARGS, "SoLinePatternElement_init(SoLinePatternElement self, SoState state)"},
	 { "SoLinePatternElement_set", _wrap_SoLinePatternElement_set, METH_VARARGS, "\n"
		"SoLinePatternElement_set(SoState state, SoNode node, int32_t const pattern, int32_t const factor=1)\n"
		"SoLinePatternElement_set(SoState state, int32_t const pattern, int32_t const factor=1)\n"
		""},
	 { "SoLinePatternElement_get", _wrap_SoLinePatternElement_get, METH_O, "SoLinePatternElement_get(SoState state) -> int32_t"},
	 { "SoLinePatternElement_getDefault", _wrap_SoLinePatternElement_getDefault, METH_NOARGS, "SoLinePatternElement_getDefault() -> int32_t"},
	 { "SoLinePatternElement_getScaleFactor", _wrap_SoLinePatternElement_getScaleFactor, METH_O, "SoLinePatternElement_getScaleFactor(SoState state) -> int32_t"},
	 { "SoLinePatternElement_getDefaultScaleFactor", _wrap_SoLinePatternElement_getDefaultScaleFactor, METH_NOARGS, "SoLinePatternElement_getDefaultScaleFactor() -> int32_t"},
	 { "SoLinePatternElement_swigregister", SoLinePatternElement_swigregister, METH_O, NULL},
	 { "SoGLLinePatternElement_getClassTypeId", _wrap_SoGLLinePatternElement_getClassTypeId, METH_NOARGS, "SoGLLinePatternElement_getClassTypeId() -> SoType"},
	 { "SoGLLinePatternElement_getClassStackIndex", _wrap_SoGLLinePatternElement_getClassStackIndex, METH_NOARGS, "SoGLLinePatternElement_getClassStackIndex() -> int"},
	 { "SoGLLinePatternElement_createInstance", _wrap_SoGLLinePatternElement_createInstance, METH_NOARGS, "SoGLLinePatternElement_createInstance() -> void *"},
	 { "SoGLLinePatternElement_initClass", _wrap_SoGLLinePatternElement_initClass, METH_NOARGS, "SoGLLinePatternElement_initClass()"},
	 { "SoGLLinePatternElement_init", _wrap_SoGLLinePatternElement_init, METH_VARARGS, "SoGLLinePatternElement_init(SoGLLinePatternElement self, SoState state)"},
	 { "SoGLLinePatternElement_push", _wrap_SoGLLinePatternElement_push, METH_VARARGS, "SoGLLinePatternElement_push(SoGLLinePatternElement self, SoState state)"},
	 { "SoGLLinePatternElement_pop", _wrap_SoGLLinePatternElement_pop, METH_VARARGS, "SoGLLinePatternElement_pop(SoGLLinePatternElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLLinePatternElement_swigregister", SoGLLinePatternElement_swigregister, METH_O, NULL},
	 { "SoSwitchElement_getClassTypeId", _wrap_SoSwitchElement_getClassTypeId, METH_NOARGS, "SoSwitchElement_getClassTypeId() -> SoType"},
	 { "SoSwitchElement_getClassStackIndex", _wrap_SoSwitchElement_getClassStackIndex, METH_NOARGS, "SoSwitchElement_getClassStackIndex() -> int"},
	 { "SoSwitchElement_createInstance", _wrap_SoSwitchElement_createInstance, METH_NOARGS, "SoSwitchElement_createInstance() -> void *"},
	 { "SoSwitchElement_initClass", _wrap_SoSwitchElement_initClass, METH_NOARGS, "SoSwitchElement_initClass()"},
	 { "SoSwitchElement_init", _wrap_SoSwitchElement_init, METH_VARARGS, "SoSwitchElement_init(SoSwitchElement self, SoState state)"},
	 { "SoSwitchElement_set", _wrap_SoSwitchElement_set, METH_VARARGS, "\n"
		"SoSwitchElement_set(SoState state, SoNode node, int32_t const index)\n"
		"SoSwitchElement_set(SoState state, int32_t const index)\n"
		""},
	 { "SoSwitchElement_get", _wrap_SoSwitchElement_get, METH_O, "SoSwitchElement_get(SoState state) -> int32_t"},
	 { "SoSwitchElement_getDefault", _wrap_SoSwitchElement_getDefault, METH_NOARGS, "SoSwitchElement_getDefault() -> int32_t"},
	 { "SoSwitchElement_swigregister", SoSwitchElement_swigregister, METH_O, NULL},
	 { "SoTextOutlineEnabledElement_getClassTypeId", _wrap_SoTextOutlineEnabledElement_getClassTypeId, METH_NOARGS, "SoTextOutlineEnabledElement_getClassTypeId() -> SoType"},
	 { "SoTextOutlineEnabledElement_getClassStackIndex", _wrap_SoTextOutlineEnabledElement_getClassStackIndex, METH_NOARGS, "SoTextOutlineEnabledElement_getClassStackIndex() -> int"},
	 { "SoTextOutlineEnabledElement_createInstance", _wrap_SoTextOutlineEnabledElement_createInstance, METH_NOARGS, "SoTextOutlineEnabledElement_createInstance() -> void *"},
	 { "SoTextOutlineEnabledElement_initClass", _wrap_SoTextOutlineEnabledElement_initClass, METH_NOARGS, "SoTextOutlineEnabledElement_initClass()"},
	 { "SoTextOutlineEnabledElement_init", _wrap_SoTextOutlineEnabledElement_init, METH_VARARGS, "SoTextOutlineEnabledElement_init(SoTextOutlineEnabledElement self, SoState state)"},
	 { "SoTextOutlineEnabledElement_push", _wrap_SoTextOutlineEnabledElement_push, METH_VARARGS, "SoTextOutlineEnabledElement_push(SoTextOutlineEnabledElement self, SoState state)"},
	 { "SoTextOutlineEnabledElement_pop", _wrap_SoTextOutlineEnabledElement_pop, METH_VARARGS, "SoTextOutlineEnabledElement_pop(SoTextOutlineEnabledElement self, SoState state, SoElement prevTopElement)"},
	 { "SoTextOutlineEnabledElement_set", _wrap_SoTextOutlineEnabledElement_set, METH_VARARGS, "\n"
		"SoTextOutlineEnabledElement_set(SoState state, SoNode node, SbBool const enabled)\n"
		"SoTextOutlineEnabledElement_set(SoState state, SbBool const enabled)\n"
		""},
	 { "SoTextOutlineEnabledElement_get", _wrap_SoTextOutlineEnabledElement_get, METH_O, "SoTextOutlineEnabledElement_get(SoState state) -> SbBool"},
	 { "SoTextOutlineEnabledElement_getDefault", _wrap_SoTextOutlineEnabledElement_getDefault, METH_NOARGS, "SoTextOutlineEnabledElement_getDefault() -> SbBool"},
	 { "SoTextOutlineEnabledElement_swigregister", SoTextOutlineEnabledElement_swigregister, METH_O, NULL},
	 { "SoUnitsElement_getClassTypeId", _wrap_SoUnitsElement_getClassTypeId, METH_NOARGS, "SoUnitsElement_getClassTypeId() -> SoType"},
	 { "SoUnitsElement_getClassStackIndex", _wrap_SoUnitsElement_getClassStackIndex, METH_NOARGS, "SoUnitsElement_getClassStackIndex() -> int"},
	 { "SoUnitsElement_createInstance", _wrap_SoUnitsElement_createInstance, METH_NOARGS, "SoUnitsElement_createInstance() -> void *"},
	 { "SoUnitsElement_initClass", _wrap_SoUnitsElement_initClass, METH_NOARGS, "SoUnitsElement_initClass()"},
	 { "SoUnitsElement_init", _wrap_SoUnitsElement_init, METH_VARARGS, "SoUnitsElement_init(SoUnitsElement self, SoState state)"},
	 { "SoUnitsElement_set", _wrap_SoUnitsElement_set, METH_VARARGS, "\n"
		"SoUnitsElement_set(SoState state, SoNode node, SoUnitsElement::Units const units)\n"
		"SoUnitsElement_set(SoState state, SoUnitsElement::Units const units)\n"
		""},
	 { "SoUnitsElement_get", _wrap_SoUnitsElement_get, METH_O, "SoUnitsElement_get(SoState state) -> SoUnitsElement::Units"},
	 { "SoUnitsElement_getDefault", _wrap_SoUnitsElement_getDefault, METH_NOARGS, "SoUnitsElement_getDefault() -> SoUnitsElement::Units"},
	 { "SoUnitsElement_swigregister", SoUnitsElement_swigregister, METH_O, NULL},
	 { "SoFocalDistanceElement_getClassTypeId", _wrap_SoFocalDistanceElement_getClassTypeId, METH_NOARGS, "SoFocalDistanceElement_getClassTypeId() -> SoType"},
	 { "SoFocalDistanceElement_getClassStackIndex", _wrap_SoFocalDistanceElement_getClassStackIndex, METH_NOARGS, "SoFocalDistanceElement_getClassStackIndex() -> int"},
	 { "SoFocalDistanceElement_createInstance", _wrap_SoFocalDistanceElement_createInstance, METH_NOARGS, "SoFocalDistanceElement_createInstance() -> void *"},
	 { "SoFocalDistanceElement_initClass", _wrap_SoFocalDistanceElement_initClass, METH_NOARGS, "SoFocalDistanceElement_initClass()"},
	 { "SoFocalDistanceElement_init", _wrap_SoFocalDistanceElement_init, METH_VARARGS, "SoFocalDistanceElement_init(SoFocalDistanceElement self, SoState state)"},
	 { "SoFocalDistanceElement_set", _wrap_SoFocalDistanceElement_set, METH_VARARGS, "\n"
		"SoFocalDistanceElement_set(SoState state, SoNode node, float const distance)\n"
		"SoFocalDistanceElement_set(SoState state, float const distance)\n"
		""},
	 { "SoFocalDistanceElement_get", _wrap_SoFocalDistanceElement_get, METH_O, "SoFocalDistanceElement_get(SoState state) -> float"},
	 { "SoFocalDistanceElement_getDefault", _wrap_SoFocalDistanceElement_getDefault, METH_NOARGS, "SoFocalDistanceElement_getDefault() -> float"},
	 { "SoFocalDistanceElement_swigregister", SoFocalDistanceElement_swigregister, METH_O, NULL},
	 { "SoFontSizeElement_getClassTypeId", _wrap_SoFontSizeElement_getClassTypeId, METH_NOARGS, "SoFontSizeElement_getClassTypeId() -> SoType"},
	 { "SoFontSizeElement_getClassStackIndex", _wrap_SoFontSizeElement_getClassStackIndex, METH_NOARGS, "SoFontSizeElement_getClassStackIndex() -> int"},
	 { "SoFontSizeElement_createInstance", _wrap_SoFontSizeElement_createInstance, METH_NOARGS, "SoFontSizeElement_createInstance() -> void *"},
	 { "SoFontSizeElement_initClass", _wrap_SoFontSizeElement_initClass, METH_NOARGS, "SoFontSizeElement_initClass()"},
	 { "SoFontSizeElement_init", _wrap_SoFontSizeElement_init, METH_VARARGS, "SoFontSizeElement_init(SoFontSizeElement self, SoState state)"},
	 { "SoFontSizeElement_set", _wrap_SoFontSizeElement_set, METH_VARARGS, "\n"
		"SoFontSizeElement_set(SoState state, SoNode node, float const fontSize)\n"
		"SoFontSizeElement_set(SoState state, float const fontSize)\n"
		""},
	 { "SoFontSizeElement_get", _wrap_SoFontSizeElement_get, METH_O, "SoFontSizeElement_get(SoState state) -> float"},
	 { "SoFontSizeElement_getDefault", _wrap_SoFontSizeElement_getDefault, METH_NOARGS, "SoFontSizeElement_getDefault() -> float"},
	 { "SoFontSizeElement_swigregister", SoFontSizeElement_swigregister, METH_O, NULL},
	 { "SoLineWidthElement_getClassTypeId", _wrap_SoLineWidthElement_getClassTypeId, METH_NOARGS, "SoLineWidthElement_getClassTypeId() -> SoType"},
	 { "SoLineWidthElement_getClassStackIndex", _wrap_SoLineWidthElement_getClassStackIndex, METH_NOARGS, "SoLineWidthElement_getClassStackIndex() -> int"},
	 { "SoLineWidthElement_createInstance", _wrap_SoLineWidthElement_createInstance, METH_NOARGS, "SoLineWidthElement_createInstance() -> void *"},
	 { "SoLineWidthElement_initClass", _wrap_SoLineWidthElement_initClass, METH_NOARGS, "SoLineWidthElement_initClass()"},
	 { "SoLineWidthElement_init", _wrap_SoLineWidthElement_init, METH_VARARGS, "SoLineWidthElement_init(SoLineWidthElement self, SoState state)"},
	 { "SoLineWidthElement_set", _wrap_SoLineWidthElement_set, METH_VARARGS, "\n"
		"SoLineWidthElement_set(SoState state, SoNode node, float const lineWidth)\n"
		"SoLineWidthElement_set(SoState state, float const lineWidth)\n"
		""},
	 { "SoLineWidthElement_get", _wrap_SoLineWidthElement_get, METH_O, "SoLineWidthElement_get(SoState state) -> float"},
	 { "SoLineWidthElement_getDefault", _wrap_SoLineWidthElement_getDefault, METH_NOARGS, "SoLineWidthElement_getDefault() -> float"},
	 { "SoLineWidthElement_swigregister", SoLineWidthElement_swigregister, METH_O, NULL},
	 { "SoGLLineWidthElement_getClassTypeId", _wrap_SoGLLineWidthElement_getClassTypeId, METH_NOARGS, "SoGLLineWidthElement_getClassTypeId() -> SoType"},
	 { "SoGLLineWidthElement_getClassStackIndex", _wrap_SoGLLineWidthElement_getClassStackIndex, METH_NOARGS, "SoGLLineWidthElement_getClassStackIndex() -> int"},
	 { "SoGLLineWidthElement_createInstance", _wrap_SoGLLineWidthElement_createInstance, METH_NOARGS, "SoGLLineWidthElement_createInstance() -> void *"},
	 { "SoGLLineWidthElement_initClass", _wrap_SoGLLineWidthElement_initClass, METH_NOARGS, "SoGLLineWidthElement_initClass()"},
	 { "SoGLLineWidthElement_init", _wrap_SoGLLineWidthElement_init, METH_VARARGS, "SoGLLineWidthElement_init(SoGLLineWidthElement self, SoState state)"},
	 { "SoGLLineWidthElement_push", _wrap_SoGLLineWidthElement_push, METH_VARARGS, "SoGLLineWidthElement_push(SoGLLineWidthElement self, SoState state)"},
	 { "SoGLLineWidthElement_pop", _wrap_SoGLLineWidthElement_pop, METH_VARARGS, "SoGLLineWidthElement_pop(SoGLLineWidthElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLLineWidthElement_swigregister", SoGLLineWidthElement_swigregister, METH_O, NULL},
	 { "SoPointSizeElement_getClassTypeId", _wrap_SoPointSizeElement_getClassTypeId, METH_NOARGS, "SoPointSizeElement_getClassTypeId() -> SoType"},
	 { "SoPointSizeElement_getClassStackIndex", _wrap_SoPointSizeElement_getClassStackIndex, METH_NOARGS, "SoPointSizeElement_getClassStackIndex() -> int"},
	 { "SoPointSizeElement_createInstance", _wrap_SoPointSizeElement_createInstance, METH_NOARGS, "SoPointSizeElement_createInstance() -> void *"},
	 { "SoPointSizeElement_initClass", _wrap_SoPointSizeElement_initClass, METH_NOARGS, "SoPointSizeElement_initClass()"},
	 { "SoPointSizeElement_init", _wrap_SoPointSizeElement_init, METH_VARARGS, "SoPointSizeElement_init(SoPointSizeElement self, SoState state)"},
	 { "SoPointSizeElement_set", _wrap_SoPointSizeElement_set, METH_VARARGS, "\n"
		"SoPointSizeElement_set(SoState state, SoNode node, float const pointSize)\n"
		"SoPointSizeElement_set(SoState state, float const pointSize)\n"
		""},
	 { "SoPointSizeElement_get", _wrap_SoPointSizeElement_get, METH_O, "SoPointSizeElement_get(SoState state) -> float"},
	 { "SoPointSizeElement_getDefault", _wrap_SoPointSizeElement_getDefault, METH_NOARGS, "SoPointSizeElement_getDefault() -> float"},
	 { "SoPointSizeElement_swigregister", SoPointSizeElement_swigregister, METH_O, NULL},
	 { "SoGLPointSizeElement_getClassTypeId", _wrap_SoGLPointSizeElement_getClassTypeId, METH_NOARGS, "SoGLPointSizeElement_getClassTypeId() -> SoType"},
	 { "SoGLPointSizeElement_getClassStackIndex", _wrap_SoGLPointSizeElement_getClassStackIndex, METH_NOARGS, "SoGLPointSizeElement_getClassStackIndex() -> int"},
	 { "SoGLPointSizeElement_createInstance", _wrap_SoGLPointSizeElement_createInstance, METH_NOARGS, "SoGLPointSizeElement_createInstance() -> void *"},
	 { "SoGLPointSizeElement_initClass", _wrap_SoGLPointSizeElement_initClass, METH_NOARGS, "SoGLPointSizeElement_initClass()"},
	 { "SoGLPointSizeElement_init", _wrap_SoGLPointSizeElement_init, METH_VARARGS, "SoGLPointSizeElement_init(SoGLPointSizeElement self, SoState state)"},
	 { "SoGLPointSizeElement_push", _wrap_SoGLPointSizeElement_push, METH_VARARGS, "SoGLPointSizeElement_push(SoGLPointSizeElement self, SoState state)"},
	 { "SoGLPointSizeElement_pop", _wrap_SoGLPointSizeElement_pop, METH_VARARGS, "SoGLPointSizeElement_pop(SoGLPointSizeElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLPointSizeElement_swigregister", SoGLPointSizeElement_swigregister, METH_O, NULL},
	 { "SoTextureQualityElement_getClassTypeId", _wrap_SoTextureQualityElement_getClassTypeId, METH_NOARGS, "SoTextureQualityElement_getClassTypeId() -> SoType"},
	 { "SoTextureQualityElement_getClassStackIndex", _wrap_SoTextureQualityElement_getClassStackIndex, METH_NOARGS, "SoTextureQualityElement_getClassStackIndex() -> int"},
	 { "SoTextureQualityElement_createInstance", _wrap_SoTextureQualityElement_createInstance, METH_NOARGS, "SoTextureQualityElement_createInstance() -> void *"},
	 { "SoTextureQualityElement_initClass", _wrap_SoTextureQualityElement_initClass, METH_NOARGS, "SoTextureQualityElement_initClass()"},
	 { "SoTextureQualityElement_init", _wrap_SoTextureQualityElement_init, METH_VARARGS, "SoTextureQualityElement_init(SoTextureQualityElement self, SoState state)"},
	 { "SoTextureQualityElement_set", _wrap_SoTextureQualityElement_set, METH_VARARGS, "\n"
		"SoTextureQualityElement_set(SoState state, SoNode node, float const quality)\n"
		"SoTextureQualityElement_set(SoState state, float const quality)\n"
		""},
	 { "SoTextureQualityElement_get", _wrap_SoTextureQualityElement_get, METH_O, "SoTextureQualityElement_get(SoState state) -> float"},
	 { "SoTextureQualityElement_getDefault", _wrap_SoTextureQualityElement_getDefault, METH_NOARGS, "SoTextureQualityElement_getDefault() -> float"},
	 { "SoTextureQualityElement_swigregister", SoTextureQualityElement_swigregister, METH_O, NULL},
	 { "SoTextureOverrideElement_getClassTypeId", _wrap_SoTextureOverrideElement_getClassTypeId, METH_NOARGS, "SoTextureOverrideElement_getClassTypeId() -> SoType"},
	 { "SoTextureOverrideElement_getClassStackIndex", _wrap_SoTextureOverrideElement_getClassStackIndex, METH_NOARGS, "SoTextureOverrideElement_getClassStackIndex() -> int"},
	 { "SoTextureOverrideElement_createInstance", _wrap_SoTextureOverrideElement_createInstance, METH_NOARGS, "SoTextureOverrideElement_createInstance() -> void *"},
	 { "SoTextureOverrideElement_initClass", _wrap_SoTextureOverrideElement_initClass, METH_NOARGS, "SoTextureOverrideElement_initClass()"},
	 { "SoTextureOverrideElement_matches", _wrap_SoTextureOverrideElement_matches, METH_VARARGS, "SoTextureOverrideElement_matches(SoTextureOverrideElement self, SoElement element) -> SbBool"},
	 { "SoTextureOverrideElement_copyMatchInfo", _wrap_SoTextureOverrideElement_copyMatchInfo, METH_O, "SoTextureOverrideElement_copyMatchInfo(SoTextureOverrideElement self) -> SoElement"},
	 { "SoTextureOverrideElement_init", _wrap_SoTextureOverrideElement_init, METH_VARARGS, "SoTextureOverrideElement_init(SoTextureOverrideElement self, SoState state)"},
	 { "SoTextureOverrideElement_push", _wrap_SoTextureOverrideElement_push, METH_VARARGS, "SoTextureOverrideElement_push(SoTextureOverrideElement self, SoState state)"},
	 { "SoTextureOverrideElement_getQualityOverride", _wrap_SoTextureOverrideElement_getQualityOverride, METH_O, "SoTextureOverrideElement_getQualityOverride(SoState state) -> SbBool"},
	 { "SoTextureOverrideElement_getImageOverride", _wrap_SoTextureOverrideElement_getImageOverride, METH_O, "SoTextureOverrideElement_getImageOverride(SoState state) -> SbBool"},
	 { "SoTextureOverrideElement_getBumpMapOverride", _wrap_SoTextureOverrideElement_getBumpMapOverride, METH_O, "SoTextureOverrideElement_getBumpMapOverride(SoState state) -> SbBool"},
	 { "SoTextureOverrideElement_setQualityOverride", _wrap_SoTextureOverrideElement_setQualityOverride, METH_VARARGS, "SoTextureOverrideElement_setQualityOverride(SoState state, SbBool const value)"},
	 { "SoTextureOverrideElement_setImageOverride", _wrap_SoTextureOverrideElement_setImageOverride, METH_VARARGS, "SoTextureOverrideElement_setImageOverride(SoState state, SbBool const value)"},
	 { "SoTextureOverrideElement_setBumpMapOverride", _wrap_SoTextureOverrideElement_setBumpMapOverride, METH_VARARGS, "SoTextureOverrideElement_setBumpMapOverride(SoState state, SbBool const value)"},
	 { "SoTextureOverrideElement_output", _wrap_SoTextureOverrideElement_output, METH_VARARGS, "SoTextureOverrideElement_output(SoTextureOverrideElement self, FILE * fp)"},
	 { "SoTextureOverrideElement_swigregister", SoTextureOverrideElement_swigregister, METH_O, NULL},
	 { "SoGLRenderPassElement_getClassTypeId", _wrap_SoGLRenderPassElement_getClassTypeId, METH_NOARGS, "SoGLRenderPassElement_getClassTypeId() -> SoType"},
	 { "SoGLRenderPassElement_getClassStackIndex", _wrap_SoGLRenderPassElement_getClassStackIndex, METH_NOARGS, "SoGLRenderPassElement_getClassStackIndex() -> int"},
	 { "SoGLRenderPassElement_createInstance", _wrap_SoGLRenderPassElement_createInstance, METH_NOARGS, "SoGLRenderPassElement_createInstance() -> void *"},
	 { "SoGLRenderPassElement_initClass", _wrap_SoGLRenderPassElement_initClass, METH_NOARGS, "SoGLRenderPassElement_initClass()"},
	 { "SoGLRenderPassElement_init", _wrap_SoGLRenderPassElement_init, METH_VARARGS, "SoGLRenderPassElement_init(SoGLRenderPassElement self, SoState state)"},
	 { "SoGLRenderPassElement_matches", _wrap_SoGLRenderPassElement_matches, METH_VARARGS, "SoGLRenderPassElement_matches(SoGLRenderPassElement self, SoElement element) -> SbBool"},
	 { "SoGLRenderPassElement_copyMatchInfo", _wrap_SoGLRenderPassElement_copyMatchInfo, METH_O, "SoGLRenderPassElement_copyMatchInfo(SoGLRenderPassElement self) -> SoElement"},
	 { "SoGLRenderPassElement_set", _wrap_SoGLRenderPassElement_set, METH_VARARGS, "SoGLRenderPassElement_set(SoState state, int const passNumber)"},
	 { "SoGLRenderPassElement_get", _wrap_SoGLRenderPassElement_get, METH_O, "SoGLRenderPassElement_get(SoState state) -> int"},
	 { "SoGLRenderPassElement_swigregister", SoGLRenderPassElement_swigregister, METH_O, NULL},
	 { "SoGLUpdateAreaElement_getClassTypeId", _wrap_SoGLUpdateAreaElement_getClassTypeId, METH_NOARGS, "SoGLUpdateAreaElement_getClassTypeId() -> SoType"},
	 { "SoGLUpdateAreaElement_getClassStackIndex", _wrap_SoGLUpdateAreaElement_getClassStackIndex, METH_NOARGS, "SoGLUpdateAreaElement_getClassStackIndex() -> int"},
	 { "SoGLUpdateAreaElement_createInstance", _wrap_SoGLUpdateAreaElement_createInstance, METH_NOARGS, "SoGLUpdateAreaElement_createInstance() -> void *"},
	 { "SoGLUpdateAreaElement_initClass", _wrap_SoGLUpdateAreaElement_initClass, METH_NOARGS, "SoGLUpdateAreaElement_initClass()"},
	 { "SoGLUpdateAreaElement_init", _wrap_SoGLUpdateAreaElement_init, METH_VARARGS, "SoGLUpdateAreaElement_init(SoGLUpdateAreaElement self, SoState state)"},
	 { "SoGLUpdateAreaElement_push", _wrap_SoGLUpdateAreaElement_push, METH_VARARGS, "SoGLUpdateAreaElement_push(SoGLUpdateAreaElement self, SoState state)"},
	 { "SoGLUpdateAreaElement_pop", _wrap_SoGLUpdateAreaElement_pop, METH_VARARGS, "SoGLUpdateAreaElement_pop(SoGLUpdateAreaElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLUpdateAreaElement_matches", _wrap_SoGLUpdateAreaElement_matches, METH_VARARGS, "SoGLUpdateAreaElement_matches(SoGLUpdateAreaElement self, SoElement element) -> SbBool"},
	 { "SoGLUpdateAreaElement_copyMatchInfo", _wrap_SoGLUpdateAreaElement_copyMatchInfo, METH_O, "SoGLUpdateAreaElement_copyMatchInfo(SoGLUpdateAreaElement self) -> SoElement"},
	 { "SoGLUpdateAreaElement_set", _wrap_SoGLUpdateAreaElement_set, METH_VARARGS, "SoGLUpdateAreaElement_set(SoState state, SbVec2f origin, SbVec2f size)"},
	 { "SoGLUpdateAreaElement_get", _wrap_SoGLUpdateAreaElement_get, METH_VARARGS, "SoGLUpdateAreaElement_get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"},
	 { "SoGLUpdateAreaElement_getDefaultOrigin", _wrap_SoGLUpdateAreaElement_getDefaultOrigin, METH_NOARGS, "SoGLUpdateAreaElement_getDefaultOrigin() -> SbVec2f"},
	 { "SoGLUpdateAreaElement_getDefaultSize", _wrap_SoGLUpdateAreaElement_getDefaultSize, METH_NOARGS, "SoGLUpdateAreaElement_getDefaultSize() -> SbVec2f"},
	 { "SoGLUpdateAreaElement_swigregister", SoGLUpdateAreaElement_swigregister, METH_O, NULL},
	 { "SoLocalBBoxMatrixElement_getClassTypeId", _wrap_SoLocalBBoxMatrixElement_getClassTypeId, METH_NOARGS, "SoLocalBBoxMatrixElement_getClassTypeId() -> SoType"},
	 { "SoLocalBBoxMatrixElement_getClassStackIndex", _wrap_SoLocalBBoxMatrixElement_getClassStackIndex, METH_NOARGS, "SoLocalBBoxMatrixElement_getClassStackIndex() -> int"},
	 { "SoLocalBBoxMatrixElement_createInstance", _wrap_SoLocalBBoxMatrixElement_createInstance, METH_NOARGS, "SoLocalBBoxMatrixElement_createInstance() -> void *"},
	 { "SoLocalBBoxMatrixElement_initClass", _wrap_SoLocalBBoxMatrixElement_initClass, METH_NOARGS, "SoLocalBBoxMatrixElement_initClass()"},
	 { "SoLocalBBoxMatrixElement_init", _wrap_SoLocalBBoxMatrixElement_init, METH_VARARGS, "SoLocalBBoxMatrixElement_init(SoLocalBBoxMatrixElement self, SoState state)"},
	 { "SoLocalBBoxMatrixElement_push", _wrap_SoLocalBBoxMatrixElement_push, METH_VARARGS, "SoLocalBBoxMatrixElement_push(SoLocalBBoxMatrixElement self, SoState state)"},
	 { "SoLocalBBoxMatrixElement_makeIdentity", _wrap_SoLocalBBoxMatrixElement_makeIdentity, METH_O, "SoLocalBBoxMatrixElement_makeIdentity(SoState state)"},
	 { "SoLocalBBoxMatrixElement_set", _wrap_SoLocalBBoxMatrixElement_set, METH_O, "SoLocalBBoxMatrixElement_set(SoState state)"},
	 { "SoLocalBBoxMatrixElement_mult", _wrap_SoLocalBBoxMatrixElement_mult, METH_O, "SoLocalBBoxMatrixElement_mult(SoState state)"},
	 { "SoLocalBBoxMatrixElement_translateBy", _wrap_SoLocalBBoxMatrixElement_translateBy, METH_VARARGS, "SoLocalBBoxMatrixElement_translateBy(SoState state, SbVec3f translation)"},
	 { "SoLocalBBoxMatrixElement_rotateBy", _wrap_SoLocalBBoxMatrixElement_rotateBy, METH_VARARGS, "SoLocalBBoxMatrixElement_rotateBy(SoState state, SbRotation rotation)"},
	 { "SoLocalBBoxMatrixElement_scaleBy", _wrap_SoLocalBBoxMatrixElement_scaleBy, METH_VARARGS, "SoLocalBBoxMatrixElement_scaleBy(SoState state, SbVec3f scaleFactor)"},
	 { "SoLocalBBoxMatrixElement_pushMatrix", _wrap_SoLocalBBoxMatrixElement_pushMatrix, METH_O, "SoLocalBBoxMatrixElement_pushMatrix(SoState state) -> SbMatrix"},
	 { "SoLocalBBoxMatrixElement_popMatrix", _wrap_SoLocalBBoxMatrixElement_popMatrix, METH_O, "SoLocalBBoxMatrixElement_popMatrix(SoState state)"},
	 { "SoLocalBBoxMatrixElement_resetAll", _wrap_SoLocalBBoxMatrixElement_resetAll, METH_O, "SoLocalBBoxMatrixElement_resetAll(SoState state)"},
	 { "SoLocalBBoxMatrixElement_get", _wrap_SoLocalBBoxMatrixElement_get, METH_O, "SoLocalBBoxMatrixElement_get(SoState state) -> SbMatrix"},
	 { "SoLocalBBoxMatrixElement_matches", _wrap_SoLocalBBoxMatrixElement_matches, METH_VARARGS, "SoLocalBBoxMatrixElement_matches(SoLocalBBoxMatrixElement self, SoElement element) -> SbBool"},
	 { "SoLocalBBoxMatrixElement_copyMatchInfo", _wrap_SoLocalBBoxMatrixElement_copyMatchInfo, METH_O, "SoLocalBBoxMatrixElement_copyMatchInfo(SoLocalBBoxMatrixElement self) -> SoElement"},
	 { "SoLocalBBoxMatrixElement_swigregister", SoLocalBBoxMatrixElement_swigregister, METH_O, NULL},
	 { "SoOverrideElement_getClassTypeId", _wrap_SoOverrideElement_getClassTypeId, METH_NOARGS, "SoOverrideElement_getClassTypeId() -> SoType"},
	 { "SoOverrideElement_getClassStackIndex", _wrap_SoOverrideElement_getClassStackIndex, METH_NOARGS, "SoOverrideElement_getClassStackIndex() -> int"},
	 { "SoOverrideElement_createInstance", _wrap_SoOverrideElement_createInstance, METH_NOARGS, "SoOverrideElement_createInstance() -> void *"},
	 { "SoOverrideElement_initClass", _wrap_SoOverrideElement_initClass, METH_NOARGS, "SoOverrideElement_initClass()"},
	 { "SoOverrideElement_init", _wrap_SoOverrideElement_init, METH_VARARGS, "SoOverrideElement_init(SoOverrideElement self, SoState state)"},
	 { "SoOverrideElement_push", _wrap_SoOverrideElement_push, METH_VARARGS, "SoOverrideElement_push(SoOverrideElement self, SoState state)"},
	 { "SoOverrideElement_matches", _wrap_SoOverrideElement_matches, METH_VARARGS, "SoOverrideElement_matches(SoOverrideElement self, SoElement element) -> SbBool"},
	 { "SoOverrideElement_copyMatchInfo", _wrap_SoOverrideElement_copyMatchInfo, METH_O, "SoOverrideElement_copyMatchInfo(SoOverrideElement self) -> SoElement"},
	 { "SoOverrideElement_getFlags", _wrap_SoOverrideElement_getFlags, METH_O, "SoOverrideElement_getFlags(SoState state) -> uint32_t"},
	 { "SoOverrideElement_getAmbientColorOverride", _wrap_SoOverrideElement_getAmbientColorOverride, METH_O, "SoOverrideElement_getAmbientColorOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getColorIndexOverride", _wrap_SoOverrideElement_getColorIndexOverride, METH_O, "SoOverrideElement_getColorIndexOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getComplexityOverride", _wrap_SoOverrideElement_getComplexityOverride, METH_O, "SoOverrideElement_getComplexityOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getComplexityTypeOverride", _wrap_SoOverrideElement_getComplexityTypeOverride, METH_O, "SoOverrideElement_getComplexityTypeOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getCreaseAngleOverride", _wrap_SoOverrideElement_getCreaseAngleOverride, METH_O, "SoOverrideElement_getCreaseAngleOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getDiffuseColorOverride", _wrap_SoOverrideElement_getDiffuseColorOverride, METH_O, "SoOverrideElement_getDiffuseColorOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getDrawStyleOverride", _wrap_SoOverrideElement_getDrawStyleOverride, METH_O, "SoOverrideElement_getDrawStyleOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getEmissiveColorOverride", _wrap_SoOverrideElement_getEmissiveColorOverride, METH_O, "SoOverrideElement_getEmissiveColorOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getFontNameOverride", _wrap_SoOverrideElement_getFontNameOverride, METH_O, "SoOverrideElement_getFontNameOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getFontSizeOverride", _wrap_SoOverrideElement_getFontSizeOverride, METH_O, "SoOverrideElement_getFontSizeOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getLightModelOverride", _wrap_SoOverrideElement_getLightModelOverride, METH_O, "SoOverrideElement_getLightModelOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getLinePatternOverride", _wrap_SoOverrideElement_getLinePatternOverride, METH_O, "SoOverrideElement_getLinePatternOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getLineWidthOverride", _wrap_SoOverrideElement_getLineWidthOverride, METH_O, "SoOverrideElement_getLineWidthOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getMaterialBindingOverride", _wrap_SoOverrideElement_getMaterialBindingOverride, METH_O, "SoOverrideElement_getMaterialBindingOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getPickStyleOverride", _wrap_SoOverrideElement_getPickStyleOverride, METH_O, "SoOverrideElement_getPickStyleOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getPointSizeOverride", _wrap_SoOverrideElement_getPointSizeOverride, METH_O, "SoOverrideElement_getPointSizeOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getPolygonOffsetOverride", _wrap_SoOverrideElement_getPolygonOffsetOverride, METH_O, "SoOverrideElement_getPolygonOffsetOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getShapeHintsOverride", _wrap_SoOverrideElement_getShapeHintsOverride, METH_O, "SoOverrideElement_getShapeHintsOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getShininessOverride", _wrap_SoOverrideElement_getShininessOverride, METH_O, "SoOverrideElement_getShininessOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getSpecularColorOverride", _wrap_SoOverrideElement_getSpecularColorOverride, METH_O, "SoOverrideElement_getSpecularColorOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getTransparencyOverride", _wrap_SoOverrideElement_getTransparencyOverride, METH_O, "SoOverrideElement_getTransparencyOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getTransparencyTypeOverride", _wrap_SoOverrideElement_getTransparencyTypeOverride, METH_O, "SoOverrideElement_getTransparencyTypeOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getNormalVectorOverride", _wrap_SoOverrideElement_getNormalVectorOverride, METH_O, "SoOverrideElement_getNormalVectorOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_getNormalBindingOverride", _wrap_SoOverrideElement_getNormalBindingOverride, METH_O, "SoOverrideElement_getNormalBindingOverride(SoState state) -> SbBool"},
	 { "SoOverrideElement_setAmbientColorOverride", _wrap_SoOverrideElement_setAmbientColorOverride, METH_VARARGS, "SoOverrideElement_setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setColorIndexOverride", _wrap_SoOverrideElement_setColorIndexOverride, METH_VARARGS, "SoOverrideElement_setColorIndexOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setComplexityOverride", _wrap_SoOverrideElement_setComplexityOverride, METH_VARARGS, "SoOverrideElement_setComplexityOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setComplexityTypeOverride", _wrap_SoOverrideElement_setComplexityTypeOverride, METH_VARARGS, "SoOverrideElement_setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setCreaseAngleOverride", _wrap_SoOverrideElement_setCreaseAngleOverride, METH_VARARGS, "SoOverrideElement_setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setDiffuseColorOverride", _wrap_SoOverrideElement_setDiffuseColorOverride, METH_VARARGS, "SoOverrideElement_setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setDrawStyleOverride", _wrap_SoOverrideElement_setDrawStyleOverride, METH_VARARGS, "SoOverrideElement_setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setEmissiveColorOverride", _wrap_SoOverrideElement_setEmissiveColorOverride, METH_VARARGS, "SoOverrideElement_setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setFontNameOverride", _wrap_SoOverrideElement_setFontNameOverride, METH_VARARGS, "SoOverrideElement_setFontNameOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setFontSizeOverride", _wrap_SoOverrideElement_setFontSizeOverride, METH_VARARGS, "SoOverrideElement_setFontSizeOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setLightModelOverride", _wrap_SoOverrideElement_setLightModelOverride, METH_VARARGS, "SoOverrideElement_setLightModelOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setLinePatternOverride", _wrap_SoOverrideElement_setLinePatternOverride, METH_VARARGS, "SoOverrideElement_setLinePatternOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setLineWidthOverride", _wrap_SoOverrideElement_setLineWidthOverride, METH_VARARGS, "SoOverrideElement_setLineWidthOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setMaterialBindingOverride", _wrap_SoOverrideElement_setMaterialBindingOverride, METH_VARARGS, "SoOverrideElement_setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setPickStyleOverride", _wrap_SoOverrideElement_setPickStyleOverride, METH_VARARGS, "SoOverrideElement_setPickStyleOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setPointSizeOverride", _wrap_SoOverrideElement_setPointSizeOverride, METH_VARARGS, "SoOverrideElement_setPointSizeOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setPolygonOffsetOverride", _wrap_SoOverrideElement_setPolygonOffsetOverride, METH_VARARGS, "SoOverrideElement_setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setShapeHintsOverride", _wrap_SoOverrideElement_setShapeHintsOverride, METH_VARARGS, "SoOverrideElement_setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setShininessOverride", _wrap_SoOverrideElement_setShininessOverride, METH_VARARGS, "SoOverrideElement_setShininessOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setSpecularColorOverride", _wrap_SoOverrideElement_setSpecularColorOverride, METH_VARARGS, "SoOverrideElement_setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setTransparencyOverride", _wrap_SoOverrideElement_setTransparencyOverride, METH_VARARGS, "SoOverrideElement_setTransparencyOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setTransparencyTypeOverride", _wrap_SoOverrideElement_setTransparencyTypeOverride, METH_VARARGS, "SoOverrideElement_setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setNormalVectorOverride", _wrap_SoOverrideElement_setNormalVectorOverride, METH_VARARGS, "SoOverrideElement_setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_setNormalBindingOverride", _wrap_SoOverrideElement_setNormalBindingOverride, METH_VARARGS, "SoOverrideElement_setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"},
	 { "SoOverrideElement_output", _wrap_SoOverrideElement_output, METH_VARARGS, "SoOverrideElement_output(SoOverrideElement self, FILE * file)"},
	 { "SoOverrideElement_swigregister", SoOverrideElement_swigregister, METH_O, NULL},
	 { "SoPickRayElement_getClassTypeId", _wrap_SoPickRayElement_getClassTypeId, METH_NOARGS, "SoPickRayElement_getClassTypeId() -> SoType"},
	 { "SoPickRayElement_getClassStackIndex", _wrap_SoPickRayElement_getClassStackIndex, METH_NOARGS, "SoPickRayElement_getClassStackIndex() -> int"},
	 { "SoPickRayElement_createInstance", _wrap_SoPickRayElement_createInstance, METH_NOARGS, "SoPickRayElement_createInstance() -> void *"},
	 { "SoPickRayElement_initClass", _wrap_SoPickRayElement_initClass, METH_NOARGS, "SoPickRayElement_initClass()"},
	 { "SoPickRayElement_init", _wrap_SoPickRayElement_init, METH_VARARGS, "SoPickRayElement_init(SoPickRayElement self, SoState state)"},
	 { "SoPickRayElement_matches", _wrap_SoPickRayElement_matches, METH_VARARGS, "SoPickRayElement_matches(SoPickRayElement self, SoElement element) -> SbBool"},
	 { "SoPickRayElement_copyMatchInfo", _wrap_SoPickRayElement_copyMatchInfo, METH_O, "SoPickRayElement_copyMatchInfo(SoPickRayElement self) -> SoElement"},
	 { "SoPickRayElement_set", _wrap_SoPickRayElement_set, METH_VARARGS, "SoPickRayElement_set(SoState state, SbViewVolume volume)"},
	 { "SoPickRayElement_get", _wrap_SoPickRayElement_get, METH_O, "SoPickRayElement_get(SoState state) -> SbViewVolume"},
	 { "SoPickRayElement_swigregister", SoPickRayElement_swigregister, METH_O, NULL},
	 { "SoGLCoordinateElement_getClassTypeId", _wrap_SoGLCoordinateElement_getClassTypeId, METH_NOARGS, "SoGLCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoGLCoordinateElement_getClassStackIndex", _wrap_SoGLCoordinateElement_getClassStackIndex, METH_NOARGS, "SoGLCoordinateElement_getClassStackIndex() -> int"},
	 { "SoGLCoordinateElement_createInstance", _wrap_SoGLCoordinateElement_createInstance, METH_NOARGS, "SoGLCoordinateElement_createInstance() -> void *"},
	 { "SoGLCoordinateElement_initClass", _wrap_SoGLCoordinateElement_initClass, METH_NOARGS, "SoGLCoordinateElement_initClass()"},
	 { "SoGLCoordinateElement_getPtr3", _wrap_SoGLCoordinateElement_getPtr3, METH_O, "SoGLCoordinateElement_getPtr3(SoGLCoordinateElement self) -> SbVec3f"},
	 { "SoGLCoordinateElement_getPtr4", _wrap_SoGLCoordinateElement_getPtr4, METH_O, "SoGLCoordinateElement_getPtr4(SoGLCoordinateElement self) -> SbVec4f"},
	 { "SoGLCoordinateElement_send", _wrap_SoGLCoordinateElement_send, METH_VARARGS, "SoGLCoordinateElement_send(SoGLCoordinateElement self, int const index)"},
	 { "SoGLCoordinateElement_swigregister", SoGLCoordinateElement_swigregister, METH_O, NULL},
	 { "SoEnvironmentElement_getClassTypeId", _wrap_SoEnvironmentElement_getClassTypeId, METH_NOARGS, "SoEnvironmentElement_getClassTypeId() -> SoType"},
	 { "SoEnvironmentElement_getClassStackIndex", _wrap_SoEnvironmentElement_getClassStackIndex, METH_NOARGS, "SoEnvironmentElement_getClassStackIndex() -> int"},
	 { "SoEnvironmentElement_createInstance", _wrap_SoEnvironmentElement_createInstance, METH_NOARGS, "SoEnvironmentElement_createInstance() -> void *"},
	 { "SoEnvironmentElement_initClass", _wrap_SoEnvironmentElement_initClass, METH_NOARGS, "SoEnvironmentElement_initClass()"},
	 { "SoEnvironmentElement_init", _wrap_SoEnvironmentElement_init, METH_VARARGS, "SoEnvironmentElement_init(SoEnvironmentElement self, SoState state)"},
	 { "SoEnvironmentElement_set", _wrap_SoEnvironmentElement_set, METH_VARARGS, "SoEnvironmentElement_set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility, float const fogStart=0.0)"},
	 { "SoEnvironmentElement_get", _wrap_SoEnvironmentElement_get, METH_VARARGS, "SoEnvironmentElement_get(SoState state, float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogStart)"},
	 { "SoEnvironmentElement_getAmbientIntensity", _wrap_SoEnvironmentElement_getAmbientIntensity, METH_O, "SoEnvironmentElement_getAmbientIntensity(SoState state) -> float"},
	 { "SoEnvironmentElement_getFogVisibility", _wrap_SoEnvironmentElement_getFogVisibility, METH_O, "SoEnvironmentElement_getFogVisibility(SoState state) -> float"},
	 { "SoEnvironmentElement_getLightAttenuation", _wrap_SoEnvironmentElement_getLightAttenuation, METH_O, "SoEnvironmentElement_getLightAttenuation(SoState state) -> SbVec3f"},
	 { "SoEnvironmentElement_getAmbientColor", _wrap_SoEnvironmentElement_getAmbientColor, METH_O, "SoEnvironmentElement_getAmbientColor(SoState state) -> SbColor"},
	 { "SoEnvironmentElement_getFogColor", _wrap_SoEnvironmentElement_getFogColor, METH_O, "SoEnvironmentElement_getFogColor(SoState state) -> SbColor"},
	 { "SoEnvironmentElement_getFogType", _wrap_SoEnvironmentElement_getFogType, METH_O, "SoEnvironmentElement_getFogType(SoState state) -> int32_t"},
	 { "SoEnvironmentElement_getDefault", _wrap_SoEnvironmentElement_getDefault, METH_VARARGS, "SoEnvironmentElement_getDefault(float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogNear)"},
	 { "SoEnvironmentElement_output", _wrap_SoEnvironmentElement_output, METH_VARARGS, "SoEnvironmentElement_output(SoEnvironmentElement self, FILE * file)"},
	 { "SoEnvironmentElement_swigregister", SoEnvironmentElement_swigregister, METH_O, NULL},
	 { "SoGLEnvironmentElement_getClassTypeId", _wrap_SoGLEnvironmentElement_getClassTypeId, METH_NOARGS, "SoGLEnvironmentElement_getClassTypeId() -> SoType"},
	 { "SoGLEnvironmentElement_getClassStackIndex", _wrap_SoGLEnvironmentElement_getClassStackIndex, METH_NOARGS, "SoGLEnvironmentElement_getClassStackIndex() -> int"},
	 { "SoGLEnvironmentElement_createInstance", _wrap_SoGLEnvironmentElement_createInstance, METH_NOARGS, "SoGLEnvironmentElement_createInstance() -> void *"},
	 { "SoGLEnvironmentElement_initClass", _wrap_SoGLEnvironmentElement_initClass, METH_NOARGS, "SoGLEnvironmentElement_initClass()"},
	 { "SoGLEnvironmentElement_init", _wrap_SoGLEnvironmentElement_init, METH_VARARGS, "SoGLEnvironmentElement_init(SoGLEnvironmentElement self, SoState state)"},
	 { "SoGLEnvironmentElement_pop", _wrap_SoGLEnvironmentElement_pop, METH_VARARGS, "SoGLEnvironmentElement_pop(SoGLEnvironmentElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLEnvironmentElement_swigregister", SoGLEnvironmentElement_swigregister, METH_O, NULL},
	 { "SoFontNameElement_getClassTypeId", _wrap_SoFontNameElement_getClassTypeId, METH_NOARGS, "SoFontNameElement_getClassTypeId() -> SoType"},
	 { "SoFontNameElement_getClassStackIndex", _wrap_SoFontNameElement_getClassStackIndex, METH_NOARGS, "SoFontNameElement_getClassStackIndex() -> int"},
	 { "SoFontNameElement_createInstance", _wrap_SoFontNameElement_createInstance, METH_NOARGS, "SoFontNameElement_createInstance() -> void *"},
	 { "SoFontNameElement_initClass", _wrap_SoFontNameElement_initClass, METH_NOARGS, "SoFontNameElement_initClass()"},
	 { "SoFontNameElement_init", _wrap_SoFontNameElement_init, METH_VARARGS, "SoFontNameElement_init(SoFontNameElement self, SoState state)"},
	 { "SoFontNameElement_set", _wrap_SoFontNameElement_set, METH_VARARGS, "SoFontNameElement_set(SoState state, SoNode node, SbName fontName)"},
	 { "SoFontNameElement_get", _wrap_SoFontNameElement_get, METH_O, "SoFontNameElement_get(SoState state) -> SbName"},
	 { "SoFontNameElement_getDefault", _wrap_SoFontNameElement_getDefault, METH_NOARGS, "SoFontNameElement_getDefault() -> SbName"},
	 { "SoFontNameElement_matches", _wrap_SoFontNameElement_matches, METH_VARARGS, "SoFontNameElement_matches(SoFontNameElement self, SoElement element) -> SbBool"},
	 { "SoFontNameElement_copyMatchInfo", _wrap_SoFontNameElement_copyMatchInfo, METH_O, "SoFontNameElement_copyMatchInfo(SoFontNameElement self) -> SoElement"},
	 { "SoFontNameElement_output", _wrap_SoFontNameElement_output, METH_VARARGS, "SoFontNameElement_output(SoFontNameElement self, FILE * file)"},
	 { "SoFontNameElement_swigregister", SoFontNameElement_swigregister, METH_O, NULL},
	 { "SoLightAttenuationElement_getClassTypeId", _wrap_SoLightAttenuationElement_getClassTypeId, METH_NOARGS, "SoLightAttenuationElement_getClassTypeId() -> SoType"},
	 { "SoLightAttenuationElement_getClassStackIndex", _wrap_SoLightAttenuationElement_getClassStackIndex, METH_NOARGS, "SoLightAttenuationElement_getClassStackIndex() -> int"},
	 { "SoLightAttenuationElement_createInstance", _wrap_SoLightAttenuationElement_createInstance, METH_NOARGS, "SoLightAttenuationElement_createInstance() -> void *"},
	 { "SoLightAttenuationElement_initClass", _wrap_SoLightAttenuationElement_initClass, METH_NOARGS, "SoLightAttenuationElement_initClass()"},
	 { "SoLightAttenuationElement_init", _wrap_SoLightAttenuationElement_init, METH_VARARGS, "SoLightAttenuationElement_init(SoLightAttenuationElement self, SoState state)"},
	 { "SoLightAttenuationElement_set", _wrap_SoLightAttenuationElement_set, METH_VARARGS, "SoLightAttenuationElement_set(SoState state, SoNode node, SbVec3f lightAttenuation)"},
	 { "SoLightAttenuationElement_get", _wrap_SoLightAttenuationElement_get, METH_O, "SoLightAttenuationElement_get(SoState state) -> SbVec3f"},
	 { "SoLightAttenuationElement_getDefault", _wrap_SoLightAttenuationElement_getDefault, METH_NOARGS, "SoLightAttenuationElement_getDefault() -> SbVec3f"},
	 { "SoLightAttenuationElement_matches", _wrap_SoLightAttenuationElement_matches, METH_VARARGS, "SoLightAttenuationElement_matches(SoLightAttenuationElement self, SoElement element) -> SbBool"},
	 { "SoLightAttenuationElement_copyMatchInfo", _wrap_SoLightAttenuationElement_copyMatchInfo, METH_O, "SoLightAttenuationElement_copyMatchInfo(SoLightAttenuationElement self) -> SoElement"},
	 { "SoLightAttenuationElement_output", _wrap_SoLightAttenuationElement_output, METH_VARARGS, "SoLightAttenuationElement_output(SoLightAttenuationElement self, FILE * file)"},
	 { "SoLightAttenuationElement_swigregister", SoLightAttenuationElement_swigregister, METH_O, NULL},
	 { "SoPolygonOffsetElement_getClassTypeId", _wrap_SoPolygonOffsetElement_getClassTypeId, METH_NOARGS, "SoPolygonOffsetElement_getClassTypeId() -> SoType"},
	 { "SoPolygonOffsetElement_getClassStackIndex", _wrap_SoPolygonOffsetElement_getClassStackIndex, METH_NOARGS, "SoPolygonOffsetElement_getClassStackIndex() -> int"},
	 { "SoPolygonOffsetElement_createInstance", _wrap_SoPolygonOffsetElement_createInstance, METH_NOARGS, "SoPolygonOffsetElement_createInstance() -> void *"},
	 { "SoPolygonOffsetElement_initClass", _wrap_SoPolygonOffsetElement_initClass, METH_NOARGS, "SoPolygonOffsetElement_initClass()"},
	 { "SoPolygonOffsetElement_init", _wrap_SoPolygonOffsetElement_init, METH_VARARGS, "SoPolygonOffsetElement_init(SoPolygonOffsetElement self, SoState state)"},
	 { "SoPolygonOffsetElement_set", _wrap_SoPolygonOffsetElement_set, METH_VARARGS, "SoPolygonOffsetElement_set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"},
	 { "SoPolygonOffsetElement_get", _wrap_SoPolygonOffsetElement_get, METH_VARARGS, "SoPolygonOffsetElement_get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"},
	 { "SoPolygonOffsetElement_getDefault", _wrap_SoPolygonOffsetElement_getDefault, METH_VARARGS, "SoPolygonOffsetElement_getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"},
	 { "SoPolygonOffsetElement_swigregister", SoPolygonOffsetElement_swigregister, METH_O, NULL},
	 { "SoGLPolygonOffsetElement_getClassTypeId", _wrap_SoGLPolygonOffsetElement_getClassTypeId, METH_NOARGS, "SoGLPolygonOffsetElement_getClassTypeId() -> SoType"},
	 { "SoGLPolygonOffsetElement_getClassStackIndex", _wrap_SoGLPolygonOffsetElement_getClassStackIndex, METH_NOARGS, "SoGLPolygonOffsetElement_getClassStackIndex() -> int"},
	 { "SoGLPolygonOffsetElement_createInstance", _wrap_SoGLPolygonOffsetElement_createInstance, METH_NOARGS, "SoGLPolygonOffsetElement_createInstance() -> void *"},
	 { "SoGLPolygonOffsetElement_initClass", _wrap_SoGLPolygonOffsetElement_initClass, METH_NOARGS, "SoGLPolygonOffsetElement_initClass()"},
	 { "SoGLPolygonOffsetElement_init", _wrap_SoGLPolygonOffsetElement_init, METH_VARARGS, "SoGLPolygonOffsetElement_init(SoGLPolygonOffsetElement self, SoState state)"},
	 { "SoGLPolygonOffsetElement_push", _wrap_SoGLPolygonOffsetElement_push, METH_VARARGS, "SoGLPolygonOffsetElement_push(SoGLPolygonOffsetElement self, SoState state)"},
	 { "SoGLPolygonOffsetElement_pop", _wrap_SoGLPolygonOffsetElement_pop, METH_VARARGS, "SoGLPolygonOffsetElement_pop(SoGLPolygonOffsetElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLPolygonOffsetElement_swigregister", SoGLPolygonOffsetElement_swigregister, METH_O, NULL},
	 { "SoProjectionMatrixElement_getClassTypeId", _wrap_SoProjectionMatrixElement_getClassTypeId, METH_NOARGS, "SoProjectionMatrixElement_getClassTypeId() -> SoType"},
	 { "SoProjectionMatrixElement_getClassStackIndex", _wrap_SoProjectionMatrixElement_getClassStackIndex, METH_NOARGS, "SoProjectionMatrixElement_getClassStackIndex() -> int"},
	 { "SoProjectionMatrixElement_createInstance", _wrap_SoProjectionMatrixElement_createInstance, METH_NOARGS, "SoProjectionMatrixElement_createInstance() -> void *"},
	 { "SoProjectionMatrixElement_initClass", _wrap_SoProjectionMatrixElement_initClass, METH_NOARGS, "SoProjectionMatrixElement_initClass()"},
	 { "SoProjectionMatrixElement_init", _wrap_SoProjectionMatrixElement_init, METH_VARARGS, "SoProjectionMatrixElement_init(SoProjectionMatrixElement self, SoState state)"},
	 { "SoProjectionMatrixElement_set", _wrap_SoProjectionMatrixElement_set, METH_VARARGS, "SoProjectionMatrixElement_set(SoState state, SoNode node)"},
	 { "SoProjectionMatrixElement_get", _wrap_SoProjectionMatrixElement_get, METH_O, "SoProjectionMatrixElement_get(SoState state) -> SbMatrix"},
	 { "SoProjectionMatrixElement_swigregister", SoProjectionMatrixElement_swigregister, METH_O, NULL},
	 { "SoGLProjectionMatrixElement_getClassTypeId", _wrap_SoGLProjectionMatrixElement_getClassTypeId, METH_NOARGS, "SoGLProjectionMatrixElement_getClassTypeId() -> SoType"},
	 { "SoGLProjectionMatrixElement_getClassStackIndex", _wrap_SoGLProjectionMatrixElement_getClassStackIndex, METH_NOARGS, "SoGLProjectionMatrixElement_getClassStackIndex() -> int"},
	 { "SoGLProjectionMatrixElement_createInstance", _wrap_SoGLProjectionMatrixElement_createInstance, METH_NOARGS, "SoGLProjectionMatrixElement_createInstance() -> void *"},
	 { "SoGLProjectionMatrixElement_initClass", _wrap_SoGLProjectionMatrixElement_initClass, METH_NOARGS, "SoGLProjectionMatrixElement_initClass()"},
	 { "SoGLProjectionMatrixElement_pop", _wrap_SoGLProjectionMatrixElement_pop, METH_VARARGS, "SoGLProjectionMatrixElement_pop(SoGLProjectionMatrixElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLProjectionMatrixElement_swigregister", SoGLProjectionMatrixElement_swigregister, METH_O, NULL},
	 { "SoProfileCoordinateElement_getClassTypeId", _wrap_SoProfileCoordinateElement_getClassTypeId, METH_NOARGS, "SoProfileCoordinateElement_getClassTypeId() -> SoType"},
	 { "SoProfileCoordinateElement_getClassStackIndex", _wrap_SoProfileCoordinateElement_getClassStackIndex, METH_NOARGS, "SoProfileCoordinateElement_getClassStackIndex() -> int"},
	 { "SoProfileCoordinateElement_createInstance", _wrap_SoProfileCoordinateElement_createInstance, METH_NOARGS, "SoProfileCoordinateElement_createInstance() -> void *"},
	 { "SoProfileCoordinateElement_initClass", _wrap_SoProfileCoordinateElement_initClass, METH_NOARGS, "SoProfileCoordinateElement_initClass()"},
	 { "SoProfileCoordinateElement_init", _wrap_SoProfileCoordinateElement_init, METH_VARARGS, "SoProfileCoordinateElement_init(SoProfileCoordinateElement self, SoState state)"},
	 { "SoProfileCoordinateElement_set2", _wrap_SoProfileCoordinateElement_set2, METH_VARARGS, "SoProfileCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"},
	 { "SoProfileCoordinateElement_set3", _wrap_SoProfileCoordinateElement_set3, METH_VARARGS, "SoProfileCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"},
	 { "SoProfileCoordinateElement_getInstance", _wrap_SoProfileCoordinateElement_getInstance, METH_O, "SoProfileCoordinateElement_getInstance(SoState state) -> SoProfileCoordinateElement"},
	 { "SoProfileCoordinateElement_getNum", _wrap_SoProfileCoordinateElement_getNum, METH_O, "SoProfileCoordinateElement_getNum(SoProfileCoordinateElement self) -> int32_t"},
	 { "SoProfileCoordinateElement_get2", _wrap_SoProfileCoordinateElement_get2, METH_VARARGS, "SoProfileCoordinateElement_get2(SoProfileCoordinateElement self, int const index) -> SbVec2f"},
	 { "SoProfileCoordinateElement_get3", _wrap_SoProfileCoordinateElement_get3, METH_VARARGS, "SoProfileCoordinateElement_get3(SoProfileCoordinateElement self, int const index) -> SbVec3f"},
	 { "SoProfileCoordinateElement_is2D", _wrap_SoProfileCoordinateElement_is2D, METH_O, "SoProfileCoordinateElement_is2D(SoProfileCoordinateElement self) -> SbBool"},
	 { "SoProfileCoordinateElement_getDefault2", _wrap_SoProfileCoordinateElement_getDefault2, METH_NOARGS, "SoProfileCoordinateElement_getDefault2() -> SbVec2f"},
	 { "SoProfileCoordinateElement_getDefault3", _wrap_SoProfileCoordinateElement_getDefault3, METH_NOARGS, "SoProfileCoordinateElement_getDefault3() -> SbVec3f"},
	 { "SoProfileCoordinateElement_getArrayPtr2", _wrap_SoProfileCoordinateElement_getArrayPtr2, METH_O, "SoProfileCoordinateElement_getArrayPtr2(SoProfileCoordinateElement self) -> SbVec2f"},
	 { "SoProfileCoordinateElement_getArrayPtr3", _wrap_SoProfileCoordinateElement_getArrayPtr3, METH_O, "SoProfileCoordinateElement_getArrayPtr3(SoProfileCoordinateElement self) -> SbVec3f"},
	 { "SoProfileCoordinateElement_swigregister", SoProfileCoordinateElement_swigregister, METH_O, NULL},
	 { "SoGLMultiTextureImageElement_getClassTypeId", _wrap_SoGLMultiTextureImageElement_getClassTypeId, METH_NOARGS, "SoGLMultiTextureImageElement_getClassTypeId() -> SoType"},
	 { "SoGLMultiTextureImageElement_getClassStackIndex", _wrap_SoGLMultiTextureImageElement_getClassStackIndex, METH_NOARGS, "SoGLMultiTextureImageElement_getClassStackIndex() -> int"},
	 { "SoGLMultiTextureImageElement_createInstance", _wrap_SoGLMultiTextureImageElement_createInstance, METH_NOARGS, "SoGLMultiTextureImageElement_createInstance() -> void *"},
	 { "SoGLMultiTextureImageElement_initClass", _wrap_SoGLMultiTextureImageElement_initClass, METH_NOARGS, "SoGLMultiTextureImageElement_initClass()"},
	 { "SoGLMultiTextureImageElement_init", _wrap_SoGLMultiTextureImageElement_init, METH_VARARGS, "SoGLMultiTextureImageElement_init(SoGLMultiTextureImageElement self, SoState state)"},
	 { "SoGLMultiTextureImageElement_push", _wrap_SoGLMultiTextureImageElement_push, METH_VARARGS, "SoGLMultiTextureImageElement_push(SoGLMultiTextureImageElement self, SoState state)"},
	 { "SoGLMultiTextureImageElement_pop", _wrap_SoGLMultiTextureImageElement_pop, METH_VARARGS, "SoGLMultiTextureImageElement_pop(SoGLMultiTextureImageElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLMultiTextureImageElement_restore", _wrap_SoGLMultiTextureImageElement_restore, METH_VARARGS, "SoGLMultiTextureImageElement_restore(SoState state, int const unit)"},
	 { "SoGLMultiTextureImageElement_hasTransparency", _wrap_SoGLMultiTextureImageElement_hasTransparency, METH_O, "SoGLMultiTextureImageElement_hasTransparency(SoState state) -> SbBool"},
	 { "SoGLMultiTextureImageElement_set", _wrap_SoGLMultiTextureImageElement_set, METH_VARARGS, "\n"
		"SoGLMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		"SoGLMultiTextureImageElement_set(SoState state, SoNode node, SoGLImage image, SoMultiTextureImageElement::Model const model, SbColor blendColor)\n"
		""},
	 { "SoGLMultiTextureImageElement_get", _wrap_SoGLMultiTextureImageElement_get, METH_VARARGS, "\n"
		"SoGLMultiTextureImageElement_get(SoState state, int const unit, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage\n"
		"SoGLMultiTextureImageElement_get(SoState state, SoMultiTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage\n"
		""},
	 { "SoGLMultiTextureImageElement_getMaxGLTextureSize", _wrap_SoGLMultiTextureImageElement_getMaxGLTextureSize, METH_NOARGS, "SoGLMultiTextureImageElement_getMaxGLTextureSize() -> int32_t"},
	 { "SoGLMultiTextureImageElement_swigregister", SoGLMultiTextureImageElement_swigregister, METH_O, NULL},
	 { "SoViewingMatrixElement_getClassTypeId", _wrap_SoViewingMatrixElement_getClassTypeId, METH_NOARGS, "SoViewingMatrixElement_getClassTypeId() -> SoType"},
	 { "SoViewingMatrixElement_getClassStackIndex", _wrap_SoViewingMatrixElement_getClassStackIndex, METH_NOARGS, "SoViewingMatrixElement_getClassStackIndex() -> int"},
	 { "SoViewingMatrixElement_createInstance", _wrap_SoViewingMatrixElement_createInstance, METH_NOARGS, "SoViewingMatrixElement_createInstance() -> void *"},
	 { "SoViewingMatrixElement_initClass", _wrap_SoViewingMatrixElement_initClass, METH_NOARGS, "SoViewingMatrixElement_initClass()"},
	 { "SoViewingMatrixElement_init", _wrap_SoViewingMatrixElement_init, METH_VARARGS, "SoViewingMatrixElement_init(SoViewingMatrixElement self, SoState state)"},
	 { "SoViewingMatrixElement_set", _wrap_SoViewingMatrixElement_set, METH_VARARGS, "SoViewingMatrixElement_set(SoState state, SoNode node, SbMatrix ViewingMatrix)"},
	 { "SoViewingMatrixElement_get", _wrap_SoViewingMatrixElement_get, METH_O, "SoViewingMatrixElement_get(SoState state) -> SbMatrix"},
	 { "SoViewingMatrixElement_swigregister", SoViewingMatrixElement_swigregister, METH_O, NULL},
	 { "SoGLViewingMatrixElement_getClassTypeId", _wrap_SoGLViewingMatrixElement_getClassTypeId, METH_NOARGS, "SoGLViewingMatrixElement_getClassTypeId() -> SoType"},
	 { "SoGLViewingMatrixElement_getClassStackIndex", _wrap_SoGLViewingMatrixElement_getClassStackIndex, METH_NOARGS, "SoGLViewingMatrixElement_getClassStackIndex() -> int"},
	 { "SoGLViewingMatrixElement_createInstance", _wrap_SoGLViewingMatrixElement_createInstance, METH_NOARGS, "SoGLViewingMatrixElement_createInstance() -> void *"},
	 { "SoGLViewingMatrixElement_initClass", _wrap_SoGLViewingMatrixElement_initClass, METH_NOARGS, "SoGLViewingMatrixElement_initClass()"},
	 { "SoGLViewingMatrixElement_init", _wrap_SoGLViewingMatrixElement_init, METH_VARARGS, "SoGLViewingMatrixElement_init(SoGLViewingMatrixElement self, SoState state)"},
	 { "SoGLViewingMatrixElement_push", _wrap_SoGLViewingMatrixElement_push, METH_VARARGS, "SoGLViewingMatrixElement_push(SoGLViewingMatrixElement self, SoState state)"},
	 { "SoGLViewingMatrixElement_pop", _wrap_SoGLViewingMatrixElement_pop, METH_VARARGS, "SoGLViewingMatrixElement_pop(SoGLViewingMatrixElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLViewingMatrixElement_getNodeId", _wrap_SoGLViewingMatrixElement_getNodeId, METH_O, "SoGLViewingMatrixElement_getNodeId(SoState state) -> SbUniqueId"},
	 { "SoGLViewingMatrixElement_getResetMatrix", _wrap_SoGLViewingMatrixElement_getResetMatrix, METH_O, "SoGLViewingMatrixElement_getResetMatrix(SoState state) -> SbMatrix"},
	 { "SoGLViewingMatrixElement_swigregister", SoGLViewingMatrixElement_swigregister, METH_O, NULL},
	 { "SoViewVolumeElement_getClassTypeId", _wrap_SoViewVolumeElement_getClassTypeId, METH_NOARGS, "SoViewVolumeElement_getClassTypeId() -> SoType"},
	 { "SoViewVolumeElement_getClassStackIndex", _wrap_SoViewVolumeElement_getClassStackIndex, METH_NOARGS, "SoViewVolumeElement_getClassStackIndex() -> int"},
	 { "SoViewVolumeElement_createInstance", _wrap_SoViewVolumeElement_createInstance, METH_NOARGS, "SoViewVolumeElement_createInstance() -> void *"},
	 { "SoViewVolumeElement_initClass", _wrap_SoViewVolumeElement_initClass, METH_NOARGS, "SoViewVolumeElement_initClass()"},
	 { "SoViewVolumeElement_init", _wrap_SoViewVolumeElement_init, METH_VARARGS, "SoViewVolumeElement_init(SoViewVolumeElement self, SoState state)"},
	 { "SoViewVolumeElement_set", _wrap_SoViewVolumeElement_set, METH_VARARGS, "SoViewVolumeElement_set(SoState state, SoNode node, SbViewVolume viewVolume)"},
	 { "SoViewVolumeElement_get", _wrap_SoViewVolumeElement_get, METH_O, "SoViewVolumeElement_get(SoState state) -> SbViewVolume"},
	 { "SoViewVolumeElement_swigregister", SoViewVolumeElement_swigregister, METH_O, NULL},
	 { "SoGLShapeHintsElement_getClassTypeId", _wrap_SoGLShapeHintsElement_getClassTypeId, METH_NOARGS, "SoGLShapeHintsElement_getClassTypeId() -> SoType"},
	 { "SoGLShapeHintsElement_getClassStackIndex", _wrap_SoGLShapeHintsElement_getClassStackIndex, METH_NOARGS, "SoGLShapeHintsElement_getClassStackIndex() -> int"},
	 { "SoGLShapeHintsElement_createInstance", _wrap_SoGLShapeHintsElement_createInstance, METH_NOARGS, "SoGLShapeHintsElement_createInstance() -> void *"},
	 { "SoGLShapeHintsElement_initClass", _wrap_SoGLShapeHintsElement_initClass, METH_NOARGS, "SoGLShapeHintsElement_initClass()"},
	 { "SoGLShapeHintsElement_init", _wrap_SoGLShapeHintsElement_init, METH_VARARGS, "SoGLShapeHintsElement_init(SoGLShapeHintsElement self, SoState state)"},
	 { "SoGLShapeHintsElement_push", _wrap_SoGLShapeHintsElement_push, METH_VARARGS, "SoGLShapeHintsElement_push(SoGLShapeHintsElement self, SoState state)"},
	 { "SoGLShapeHintsElement_pop", _wrap_SoGLShapeHintsElement_pop, METH_VARARGS, "SoGLShapeHintsElement_pop(SoGLShapeHintsElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLShapeHintsElement_forceSend", _wrap_SoGLShapeHintsElement_forceSend, METH_VARARGS, "\n"
		"SoGLShapeHintsElement_forceSend(SoState state, SbBool const twoside)\n"
		"SoGLShapeHintsElement_forceSend(SoState state, SbBool const ccw, SbBool const cull)\n"
		"SoGLShapeHintsElement_forceSend(SoState state, SbBool const ccw, SbBool const cull, SbBool const twoside)\n"
		""},
	 { "SoGLShapeHintsElement_swigregister", SoGLShapeHintsElement_swigregister, METH_O, NULL},
	 { "SoShapeStyleElement_getClassTypeId", _wrap_SoShapeStyleElement_getClassTypeId, METH_NOARGS, "SoShapeStyleElement_getClassTypeId() -> SoType"},
	 { "SoShapeStyleElement_getClassStackIndex", _wrap_SoShapeStyleElement_getClassStackIndex, METH_NOARGS, "SoShapeStyleElement_getClassStackIndex() -> int"},
	 { "SoShapeStyleElement_createInstance", _wrap_SoShapeStyleElement_createInstance, METH_NOARGS, "SoShapeStyleElement_createInstance() -> void *"},
	 { "SoShapeStyleElement_initClass", _wrap_SoShapeStyleElement_initClass, METH_NOARGS, "SoShapeStyleElement_initClass()"},
	 { "SoShapeStyleElement_init", _wrap_SoShapeStyleElement_init, METH_VARARGS, "SoShapeStyleElement_init(SoShapeStyleElement self, SoState state)"},
	 { "SoShapeStyleElement_push", _wrap_SoShapeStyleElement_push, METH_VARARGS, "SoShapeStyleElement_push(SoShapeStyleElement self, SoState state)"},
	 { "SoShapeStyleElement_pop", _wrap_SoShapeStyleElement_pop, METH_VARARGS, "SoShapeStyleElement_pop(SoShapeStyleElement self, SoState state, SoElement prevTopElement)"},
	 { "SoShapeStyleElement_matches", _wrap_SoShapeStyleElement_matches, METH_VARARGS, "SoShapeStyleElement_matches(SoShapeStyleElement self, SoElement element) -> SbBool"},
	 { "SoShapeStyleElement_copyMatchInfo", _wrap_SoShapeStyleElement_copyMatchInfo, METH_O, "SoShapeStyleElement_copyMatchInfo(SoShapeStyleElement self) -> SoElement"},
	 { "SoShapeStyleElement_get", _wrap_SoShapeStyleElement_get, METH_O, "SoShapeStyleElement_get(SoState state) -> SoShapeStyleElement"},
	 { "SoShapeStyleElement_getFlags", _wrap_SoShapeStyleElement_getFlags, METH_O, "SoShapeStyleElement_getFlags(SoShapeStyleElement self) -> unsigned int"},
	 { "SoShapeStyleElement_mightNotRender", _wrap_SoShapeStyleElement_mightNotRender, METH_O, "SoShapeStyleElement_mightNotRender(SoShapeStyleElement self) -> SbBool"},
	 { "SoShapeStyleElement_needNormals", _wrap_SoShapeStyleElement_needNormals, METH_O, "SoShapeStyleElement_needNormals(SoShapeStyleElement self) -> SbBool"},
	 { "SoShapeStyleElement_needTexCoords", _wrap_SoShapeStyleElement_needTexCoords, METH_O, "SoShapeStyleElement_needTexCoords(SoShapeStyleElement self) -> SbBool"},
	 { "SoShapeStyleElement_getRenderCaseMask", _wrap_SoShapeStyleElement_getRenderCaseMask, METH_O, "SoShapeStyleElement_getRenderCaseMask(SoShapeStyleElement self) -> int"},
	 { "SoShapeStyleElement_setDrawStyle", _wrap_SoShapeStyleElement_setDrawStyle, METH_VARARGS, "SoShapeStyleElement_setDrawStyle(SoState state, int32_t const value)"},
	 { "SoShapeStyleElement_setComplexityType", _wrap_SoShapeStyleElement_setComplexityType, METH_VARARGS, "SoShapeStyleElement_setComplexityType(SoState state, int32_t const value)"},
	 { "SoShapeStyleElement_setTransparencyType", _wrap_SoShapeStyleElement_setTransparencyType, METH_VARARGS, "SoShapeStyleElement_setTransparencyType(SoState state, int32_t const value)"},
	 { "SoShapeStyleElement_setTextureEnabled", _wrap_SoShapeStyleElement_setTextureEnabled, METH_VARARGS, "SoShapeStyleElement_setTextureEnabled(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setTexture3Enabled", _wrap_SoShapeStyleElement_setTexture3Enabled, METH_VARARGS, "SoShapeStyleElement_setTexture3Enabled(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setTextureFunction", _wrap_SoShapeStyleElement_setTextureFunction, METH_VARARGS, "SoShapeStyleElement_setTextureFunction(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setLightModel", _wrap_SoShapeStyleElement_setLightModel, METH_VARARGS, "SoShapeStyleElement_setLightModel(SoState state, int32_t const value)"},
	 { "SoShapeStyleElement_setOverrides", _wrap_SoShapeStyleElement_setOverrides, METH_VARARGS, "SoShapeStyleElement_setOverrides(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_isScreenDoor", _wrap_SoShapeStyleElement_isScreenDoor, METH_O, "SoShapeStyleElement_isScreenDoor(SoState state) -> SbBool"},
	 { "SoShapeStyleElement_getTransparencyType", _wrap_SoShapeStyleElement_getTransparencyType, METH_O, "SoShapeStyleElement_getTransparencyType(SoState state) -> int"},
	 { "SoShapeStyleElement_isTextureFunction", _wrap_SoShapeStyleElement_isTextureFunction, METH_O, "SoShapeStyleElement_isTextureFunction(SoShapeStyleElement self) -> SbBool"},
	 { "SoShapeStyleElement_setBumpmapEnabled", _wrap_SoShapeStyleElement_setBumpmapEnabled, METH_VARARGS, "SoShapeStyleElement_setBumpmapEnabled(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setBigImageEnabled", _wrap_SoShapeStyleElement_setBigImageEnabled, METH_VARARGS, "SoShapeStyleElement_setBigImageEnabled(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setVertexArrayRendering", _wrap_SoShapeStyleElement_setVertexArrayRendering, METH_VARARGS, "SoShapeStyleElement_setVertexArrayRendering(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setTransparentMaterial", _wrap_SoShapeStyleElement_setTransparentMaterial, METH_VARARGS, "SoShapeStyleElement_setTransparentMaterial(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setTransparentTexture", _wrap_SoShapeStyleElement_setTransparentTexture, METH_VARARGS, "SoShapeStyleElement_setTransparentTexture(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setShadowMapRendering", _wrap_SoShapeStyleElement_setShadowMapRendering, METH_VARARGS, "SoShapeStyleElement_setShadowMapRendering(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_setShadowsRendering", _wrap_SoShapeStyleElement_setShadowsRendering, METH_VARARGS, "SoShapeStyleElement_setShadowsRendering(SoState state, SbBool const value)"},
	 { "SoShapeStyleElement_swigregister", SoShapeStyleElement_swigregister, METH_O, NULL},
	 { "SoViewportRegionElement_getClassTypeId", _wrap_SoViewportRegionElement_getClassTypeId, METH_NOARGS, "SoViewportRegionElement_getClassTypeId() -> SoType"},
	 { "SoViewportRegionElement_getClassStackIndex", _wrap_SoViewportRegionElement_getClassStackIndex, METH_NOARGS, "SoViewportRegionElement_getClassStackIndex() -> int"},
	 { "SoViewportRegionElement_createInstance", _wrap_SoViewportRegionElement_createInstance, METH_NOARGS, "SoViewportRegionElement_createInstance() -> void *"},
	 { "SoViewportRegionElement_initClass", _wrap_SoViewportRegionElement_initClass, METH_NOARGS, "SoViewportRegionElement_initClass()"},
	 { "SoViewportRegionElement_init", _wrap_SoViewportRegionElement_init, METH_VARARGS, "SoViewportRegionElement_init(SoViewportRegionElement self, SoState state)"},
	 { "SoViewportRegionElement_matches", _wrap_SoViewportRegionElement_matches, METH_VARARGS, "SoViewportRegionElement_matches(SoViewportRegionElement self, SoElement element) -> SbBool"},
	 { "SoViewportRegionElement_copyMatchInfo", _wrap_SoViewportRegionElement_copyMatchInfo, METH_O, "SoViewportRegionElement_copyMatchInfo(SoViewportRegionElement self) -> SoElement"},
	 { "SoViewportRegionElement_set", _wrap_SoViewportRegionElement_set, METH_VARARGS, "SoViewportRegionElement_set(SoState state, SbViewportRegion viewportRegion)"},
	 { "SoViewportRegionElement_get", _wrap_SoViewportRegionElement_get, METH_O, "SoViewportRegionElement_get(SoState state) -> SbViewportRegion"},
	 { "SoViewportRegionElement_output", _wrap_SoViewportRegionElement_output, METH_VARARGS, "SoViewportRegionElement_output(SoViewportRegionElement self, FILE * file)"},
	 { "SoViewportRegionElement_swigregister", SoViewportRegionElement_swigregister, METH_O, NULL},
	 { "SoGLViewportRegionElement_getClassTypeId", _wrap_SoGLViewportRegionElement_getClassTypeId, METH_NOARGS, "SoGLViewportRegionElement_getClassTypeId() -> SoType"},
	 { "SoGLViewportRegionElement_getClassStackIndex", _wrap_SoGLViewportRegionElement_getClassStackIndex, METH_NOARGS, "SoGLViewportRegionElement_getClassStackIndex() -> int"},
	 { "SoGLViewportRegionElement_createInstance", _wrap_SoGLViewportRegionElement_createInstance, METH_NOARGS, "SoGLViewportRegionElement_createInstance() -> void *"},
	 { "SoGLViewportRegionElement_initClass", _wrap_SoGLViewportRegionElement_initClass, METH_NOARGS, "SoGLViewportRegionElement_initClass()"},
	 { "SoGLViewportRegionElement_init", _wrap_SoGLViewportRegionElement_init, METH_VARARGS, "SoGLViewportRegionElement_init(SoGLViewportRegionElement self, SoState state)"},
	 { "SoGLViewportRegionElement_push", _wrap_SoGLViewportRegionElement_push, METH_VARARGS, "SoGLViewportRegionElement_push(SoGLViewportRegionElement self, SoState state)"},
	 { "SoGLViewportRegionElement_pop", _wrap_SoGLViewportRegionElement_pop, METH_VARARGS, "SoGLViewportRegionElement_pop(SoGLViewportRegionElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLViewportRegionElement_swigregister", SoGLViewportRegionElement_swigregister, METH_O, NULL},
	 { "SoWindowElement_getClassTypeId", _wrap_SoWindowElement_getClassTypeId, METH_NOARGS, "SoWindowElement_getClassTypeId() -> SoType"},
	 { "SoWindowElement_getClassStackIndex", _wrap_SoWindowElement_getClassStackIndex, METH_NOARGS, "SoWindowElement_getClassStackIndex() -> int"},
	 { "SoWindowElement_createInstance", _wrap_SoWindowElement_createInstance, METH_NOARGS, "SoWindowElement_createInstance() -> void *"},
	 { "SoWindowElement_initClass", _wrap_SoWindowElement_initClass, METH_NOARGS, "SoWindowElement_initClass()"},
	 { "SoWindowElement_init", _wrap_SoWindowElement_init, METH_VARARGS, "SoWindowElement_init(SoWindowElement self, SoState state)"},
	 { "SoWindowElement_push", _wrap_SoWindowElement_push, METH_VARARGS, "SoWindowElement_push(SoWindowElement self, SoState state)"},
	 { "SoWindowElement_pop", _wrap_SoWindowElement_pop, METH_VARARGS, "SoWindowElement_pop(SoWindowElement self, SoState state, SoElement prevTopElement)"},
	 { "SoWindowElement_matches", _wrap_SoWindowElement_matches, METH_VARARGS, "SoWindowElement_matches(SoWindowElement self, SoElement element) -> SbBool"},
	 { "SoWindowElement_copyMatchInfo", _wrap_SoWindowElement_copyMatchInfo, METH_O, "SoWindowElement_copyMatchInfo(SoWindowElement self) -> SoElement"},
	 { "SoWindowElement_set", _wrap_SoWindowElement_set, METH_VARARGS, "SoWindowElement_set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"},
	 { "SoWindowElement_get", _wrap_SoWindowElement_get, METH_VARARGS, "SoWindowElement_get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"},
	 { "SoWindowElement_swigregister", SoWindowElement_swigregister, METH_O, NULL},
	 { "SoGLCacheContextElement_getClassTypeId", _wrap_SoGLCacheContextElement_getClassTypeId, METH_NOARGS, "SoGLCacheContextElement_getClassTypeId() -> SoType"},
	 { "SoGLCacheContextElement_getClassStackIndex", _wrap_SoGLCacheContextElement_getClassStackIndex, METH_NOARGS, "SoGLCacheContextElement_getClassStackIndex() -> int"},
	 { "SoGLCacheContextElement_createInstance", _wrap_SoGLCacheContextElement_createInstance, METH_NOARGS, "SoGLCacheContextElement_createInstance() -> void *"},
	 { "SoGLCacheContextElement_initClass", _wrap_SoGLCacheContextElement_initClass, METH_NOARGS, "SoGLCacheContextElement_initClass()"},
	 { "SoGLCacheContextElement_init", _wrap_SoGLCacheContextElement_init, METH_VARARGS, "SoGLCacheContextElement_init(SoGLCacheContextElement self, SoState state)"},
	 { "SoGLCacheContextElement_matches", _wrap_SoGLCacheContextElement_matches, METH_VARARGS, "SoGLCacheContextElement_matches(SoGLCacheContextElement self, SoElement elt) -> SbBool"},
	 { "SoGLCacheContextElement_copyMatchInfo", _wrap_SoGLCacheContextElement_copyMatchInfo, METH_O, "SoGLCacheContextElement_copyMatchInfo(SoGLCacheContextElement self) -> SoElement"},
	 { "SoGLCacheContextElement_set", _wrap_SoGLCacheContextElement_set, METH_VARARGS, "SoGLCacheContextElement_set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"},
	 { "SoGLCacheContextElement_get", _wrap_SoGLCacheContextElement_get, METH_O, "SoGLCacheContextElement_get(SoState state) -> int"},
	 { "SoGLCacheContextElement_getExtID", _wrap_SoGLCacheContextElement_getExtID, METH_O, "SoGLCacheContextElement_getExtID(char const * str) -> int"},
	 { "SoGLCacheContextElement_getOpenGLVersion", _wrap_SoGLCacheContextElement_getOpenGLVersion, METH_VARARGS, "SoGLCacheContextElement_getOpenGLVersion(SoState state, int & major, int & minor)"},
	 { "SoGLCacheContextElement_extSupported", _wrap_SoGLCacheContextElement_extSupported, METH_VARARGS, "SoGLCacheContextElement_extSupported(SoState state, int extid) -> SbBool"},
	 { "SoGLCacheContextElement_areMipMapsFast", _wrap_SoGLCacheContextElement_areMipMapsFast, METH_O, "SoGLCacheContextElement_areMipMapsFast(SoState state) -> SbBool"},
	 { "SoGLCacheContextElement_shouldAutoCache", _wrap_SoGLCacheContextElement_shouldAutoCache, METH_VARARGS, "SoGLCacheContextElement_shouldAutoCache(SoState state, int bits)"},
	 { "SoGLCacheContextElement_setAutoCacheBits", _wrap_SoGLCacheContextElement_setAutoCacheBits, METH_VARARGS, "SoGLCacheContextElement_setAutoCacheBits(SoState state, int bits)"},
	 { "SoGLCacheContextElement_resetAutoCacheBits", _wrap_SoGLCacheContextElement_resetAutoCacheBits, METH_O, "SoGLCacheContextElement_resetAutoCacheBits(SoState state) -> int"},
	 { "SoGLCacheContextElement_getIsRemoteRendering", _wrap_SoGLCacheContextElement_getIsRemoteRendering, METH_O, "SoGLCacheContextElement_getIsRemoteRendering(SoState state) -> SbBool"},
	 { "SoGLCacheContextElement_getUniqueCacheContext", _wrap_SoGLCacheContextElement_getUniqueCacheContext, METH_NOARGS, "SoGLCacheContextElement_getUniqueCacheContext() -> uint32_t"},
	 { "SoGLCacheContextElement_scheduleDeleteCallback", _wrap_SoGLCacheContextElement_scheduleDeleteCallback, METH_VARARGS, "SoGLCacheContextElement_scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"},
	 { "SoGLCacheContextElement_incNumShapes", _wrap_SoGLCacheContextElement_incNumShapes, METH_O, "SoGLCacheContextElement_incNumShapes(SoState state)"},
	 { "SoGLCacheContextElement_getNumShapes", _wrap_SoGLCacheContextElement_getNumShapes, METH_O, "SoGLCacheContextElement_getNumShapes(SoState state) -> int"},
	 { "SoGLCacheContextElement_incNumSeparators", _wrap_SoGLCacheContextElement_incNumSeparators, METH_O, "SoGLCacheContextElement_incNumSeparators(SoState state)"},
	 { "SoGLCacheContextElement_getNumSeparators", _wrap_SoGLCacheContextElement_getNumSeparators, METH_O, "SoGLCacheContextElement_getNumSeparators(SoState state) -> int"},
	 { "SoGLCacheContextElement_swigregister", SoGLCacheContextElement_swigregister, METH_O, NULL},
	 { "new_SoGLDisplayList", _wrap_new_SoGLDisplayList, METH_VARARGS, "SoGLDisplayList(SoState state, SoGLDisplayList::Type type, int allocnum=1, SbBool mipmaptexobj=0)"},
	 { "SoGLDisplayList_ref", _wrap_SoGLDisplayList_ref, METH_O, "SoGLDisplayList_ref(SoGLDisplayList self)"},
	 { "SoGLDisplayList_unref", _wrap_SoGLDisplayList_unref, METH_VARARGS, "SoGLDisplayList_unref(SoGLDisplayList self, SoState state=None)"},
	 { "SoGLDisplayList_open", _wrap_SoGLDisplayList_open, METH_VARARGS, "SoGLDisplayList_open(SoGLDisplayList self, SoState state, int index=0)"},
	 { "SoGLDisplayList_close", _wrap_SoGLDisplayList_close, METH_VARARGS, "SoGLDisplayList_close(SoGLDisplayList self, SoState state)"},
	 { "SoGLDisplayList_call", _wrap_SoGLDisplayList_call, METH_VARARGS, "SoGLDisplayList_call(SoGLDisplayList self, SoState state, int index=0)"},
	 { "SoGLDisplayList_addDependency", _wrap_SoGLDisplayList_addDependency, METH_VARARGS, "SoGLDisplayList_addDependency(SoGLDisplayList self, SoState state)"},
	 { "SoGLDisplayList_isMipMapTextureObject", _wrap_SoGLDisplayList_isMipMapTextureObject, METH_O, "SoGLDisplayList_isMipMapTextureObject(SoGLDisplayList self) -> SbBool"},
	 { "SoGLDisplayList_getType", _wrap_SoGLDisplayList_getType, METH_O, "SoGLDisplayList_getType(SoGLDisplayList self) -> SoGLDisplayList::Type"},
	 { "SoGLDisplayList_getNumAllocated", _wrap_SoGLDisplayList_getNumAllocated, METH_O, "SoGLDisplayList_getNumAllocated(SoGLDisplayList self) -> int"},
	 { "SoGLDisplayList_getFirstIndex", _wrap_SoGLDisplayList_getFirstIndex, METH_O, "SoGLDisplayList_getFirstIndex(SoGLDisplayList self) -> unsigned int"},
	 { "SoGLDisplayList_getContext", _wrap_SoGLDisplayList_getContext, METH_O, "SoGLDisplayList_getContext(SoGLDisplayList self) -> int"},
	 { "SoGLDisplayList_setTextureTarget", _wrap_SoGLDisplayList_setTextureTarget, METH_VARARGS, "SoGLDisplayList_setTextureTarget(SoGLDisplayList self, int target)"},
	 { "SoGLDisplayList_getTextureTarget", _wrap_SoGLDisplayList_getTextureTarget, METH_O, "SoGLDisplayList_getTextureTarget(SoGLDisplayList self) -> int"},
	 { "SoGLDisplayList_swigregister", SoGLDisplayList_swigregister, METH_O, NULL},
	 { "SoGLDisplayList_swiginit", SoGLDisplayList_swiginit, METH_VARARGS, NULL},
	 { "SoGLColorIndexElement_getClassTypeId", _wrap_SoGLColorIndexElement_getClassTypeId, METH_NOARGS, "SoGLColorIndexElement_getClassTypeId() -> SoType"},
	 { "SoGLColorIndexElement_getClassStackIndex", _wrap_SoGLColorIndexElement_getClassStackIndex, METH_NOARGS, "SoGLColorIndexElement_getClassStackIndex() -> int"},
	 { "SoGLColorIndexElement_createInstance", _wrap_SoGLColorIndexElement_createInstance, METH_NOARGS, "SoGLColorIndexElement_createInstance() -> void *"},
	 { "SoGLColorIndexElement_initClass", _wrap_SoGLColorIndexElement_initClass, METH_NOARGS, "SoGLColorIndexElement_initClass()"},
	 { "SoGLColorIndexElement_isColorIndexMode", _wrap_SoGLColorIndexElement_isColorIndexMode, METH_O, "SoGLColorIndexElement_isColorIndexMode(SoState state) -> SbBool"},
	 { "SoGLColorIndexElement_init", _wrap_SoGLColorIndexElement_init, METH_VARARGS, "SoGLColorIndexElement_init(SoGLColorIndexElement self, SoState state)"},
	 { "SoGLColorIndexElement_set", _wrap_SoGLColorIndexElement_set, METH_VARARGS, "SoGLColorIndexElement_set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"},
	 { "SoGLColorIndexElement_getInstance", _wrap_SoGLColorIndexElement_getInstance, METH_O, "SoGLColorIndexElement_getInstance(SoState state) -> SoGLColorIndexElement"},
	 { "SoGLColorIndexElement_getNum", _wrap_SoGLColorIndexElement_getNum, METH_O, "SoGLColorIndexElement_getNum(SoGLColorIndexElement self) -> int32_t"},
	 { "SoGLColorIndexElement_get", _wrap_SoGLColorIndexElement_get, METH_VARARGS, "SoGLColorIndexElement_get(SoGLColorIndexElement self, int const index) -> int32_t"},
	 { "SoGLColorIndexElement_getDefault", _wrap_SoGLColorIndexElement_getDefault, METH_NOARGS, "SoGLColorIndexElement_getDefault() -> int32_t"},
	 { "SoGLColorIndexElement_swigregister", SoGLColorIndexElement_swigregister, METH_O, NULL},
	 { "SoListenerPositionElement_getClassTypeId", _wrap_SoListenerPositionElement_getClassTypeId, METH_NOARGS, "SoListenerPositionElement_getClassTypeId() -> SoType"},
	 { "SoListenerPositionElement_getClassStackIndex", _wrap_SoListenerPositionElement_getClassStackIndex, METH_NOARGS, "SoListenerPositionElement_getClassStackIndex() -> int"},
	 { "SoListenerPositionElement_createInstance", _wrap_SoListenerPositionElement_createInstance, METH_NOARGS, "SoListenerPositionElement_createInstance() -> void *"},
	 { "SoListenerPositionElement_initClass", _wrap_SoListenerPositionElement_initClass, METH_NOARGS, "SoListenerPositionElement_initClass()"},
	 { "SoListenerPositionElement_init", _wrap_SoListenerPositionElement_init, METH_VARARGS, "SoListenerPositionElement_init(SoListenerPositionElement self, SoState state)"},
	 { "SoListenerPositionElement_set", _wrap_SoListenerPositionElement_set, METH_VARARGS, "SoListenerPositionElement_set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"},
	 { "SoListenerPositionElement_get", _wrap_SoListenerPositionElement_get, METH_O, "SoListenerPositionElement_get(SoState state) -> SbVec3f"},
	 { "SoListenerPositionElement_isSetByListener", _wrap_SoListenerPositionElement_isSetByListener, METH_O, "SoListenerPositionElement_isSetByListener(SoState state) -> SbBool"},
	 { "SoListenerPositionElement_output", _wrap_SoListenerPositionElement_output, METH_VARARGS, "SoListenerPositionElement_output(SoListenerPositionElement self, FILE * file)"},
	 { "SoListenerPositionElement_swigregister", SoListenerPositionElement_swigregister, METH_O, NULL},
	 { "SoListenerOrientationElement_getClassTypeId", _wrap_SoListenerOrientationElement_getClassTypeId, METH_NOARGS, "SoListenerOrientationElement_getClassTypeId() -> SoType"},
	 { "SoListenerOrientationElement_getClassStackIndex", _wrap_SoListenerOrientationElement_getClassStackIndex, METH_NOARGS, "SoListenerOrientationElement_getClassStackIndex() -> int"},
	 { "SoListenerOrientationElement_createInstance", _wrap_SoListenerOrientationElement_createInstance, METH_NOARGS, "SoListenerOrientationElement_createInstance() -> void *"},
	 { "SoListenerOrientationElement_initClass", _wrap_SoListenerOrientationElement_initClass, METH_NOARGS, "SoListenerOrientationElement_initClass()"},
	 { "SoListenerOrientationElement_init", _wrap_SoListenerOrientationElement_init, METH_VARARGS, "SoListenerOrientationElement_init(SoListenerOrientationElement self, SoState state)"},
	 { "SoListenerOrientationElement_set", _wrap_SoListenerOrientationElement_set, METH_VARARGS, "SoListenerOrientationElement_set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"},
	 { "SoListenerOrientationElement_get", _wrap_SoListenerOrientationElement_get, METH_O, "SoListenerOrientationElement_get(SoState state) -> SbRotation"},
	 { "SoListenerOrientationElement_isSetByListener", _wrap_SoListenerOrientationElement_isSetByListener, METH_O, "SoListenerOrientationElement_isSetByListener(SoState state) -> SbBool"},
	 { "SoListenerOrientationElement_output", _wrap_SoListenerOrientationElement_output, METH_VARARGS, "SoListenerOrientationElement_output(SoListenerOrientationElement self, FILE * file)"},
	 { "SoListenerOrientationElement_swigregister", SoListenerOrientationElement_swigregister, METH_O, NULL},
	 { "SoListenerDopplerElement_getClassTypeId", _wrap_SoListenerDopplerElement_getClassTypeId, METH_NOARGS, "SoListenerDopplerElement_getClassTypeId() -> SoType"},
	 { "SoListenerDopplerElement_getClassStackIndex", _wrap_SoListenerDopplerElement_getClassStackIndex, METH_NOARGS, "SoListenerDopplerElement_getClassStackIndex() -> int"},
	 { "SoListenerDopplerElement_createInstance", _wrap_SoListenerDopplerElement_createInstance, METH_NOARGS, "SoListenerDopplerElement_createInstance() -> void *"},
	 { "SoListenerDopplerElement_initClass", _wrap_SoListenerDopplerElement_initClass, METH_NOARGS, "SoListenerDopplerElement_initClass()"},
	 { "SoListenerDopplerElement_init", _wrap_SoListenerDopplerElement_init, METH_VARARGS, "SoListenerDopplerElement_init(SoListenerDopplerElement self, SoState state)"},
	 { "SoListenerDopplerElement_setDopplerVelocity", _wrap_SoListenerDopplerElement_setDopplerVelocity, METH_VARARGS, "SoListenerDopplerElement_setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"},
	 { "SoListenerDopplerElement_setDopplerFactor", _wrap_SoListenerDopplerElement_setDopplerFactor, METH_VARARGS, "SoListenerDopplerElement_setDopplerFactor(SoState state, SoNode node, float factor)"},
	 { "SoListenerDopplerElement_getDopplerVelocity", _wrap_SoListenerDopplerElement_getDopplerVelocity, METH_O, "SoListenerDopplerElement_getDopplerVelocity(SoState state) -> SbVec3f"},
	 { "SoListenerDopplerElement_getDopplerFactor", _wrap_SoListenerDopplerElement_getDopplerFactor, METH_O, "SoListenerDopplerElement_getDopplerFactor(SoState state) -> float"},
	 { "SoListenerDopplerElement_output", _wrap_SoListenerDopplerElement_output, METH_VARARGS, "SoListenerDopplerElement_output(SoListenerDopplerElement self, FILE * file)"},
	 { "SoListenerDopplerElement_swigregister", SoListenerDopplerElement_swigregister, METH_O, NULL},
	 { "SoListenerGainElement_getClassTypeId", _wrap_SoListenerGainElement_getClassTypeId, METH_NOARGS, "SoListenerGainElement_getClassTypeId() -> SoType"},
	 { "SoListenerGainElement_getClassStackIndex", _wrap_SoListenerGainElement_getClassStackIndex, METH_NOARGS, "SoListenerGainElement_getClassStackIndex() -> int"},
	 { "SoListenerGainElement_createInstance", _wrap_SoListenerGainElement_createInstance, METH_NOARGS, "SoListenerGainElement_createInstance() -> void *"},
	 { "SoListenerGainElement_initClass", _wrap_SoListenerGainElement_initClass, METH_NOARGS, "SoListenerGainElement_initClass()"},
	 { "SoListenerGainElement_init", _wrap_SoListenerGainElement_init, METH_VARARGS, "SoListenerGainElement_init(SoListenerGainElement self, SoState state)"},
	 { "SoListenerGainElement_set", _wrap_SoListenerGainElement_set, METH_VARARGS, "\n"
		"SoListenerGainElement_set(SoState state, SoNode node, float const gain)\n"
		"SoListenerGainElement_set(SoState state, float const gain)\n"
		""},
	 { "SoListenerGainElement_get", _wrap_SoListenerGainElement_get, METH_O, "SoListenerGainElement_get(SoState state) -> float"},
	 { "SoListenerGainElement_swigregister", SoListenerGainElement_swigregister, METH_O, NULL},
	 { "SoSoundElement_getClassTypeId", _wrap_SoSoundElement_getClassTypeId, METH_NOARGS, "SoSoundElement_getClassTypeId() -> SoType"},
	 { "SoSoundElement_getClassStackIndex", _wrap_SoSoundElement_getClassStackIndex, METH_NOARGS, "SoSoundElement_getClassStackIndex() -> int"},
	 { "SoSoundElement_createInstance", _wrap_SoSoundElement_createInstance, METH_NOARGS, "SoSoundElement_createInstance() -> void *"},
	 { "SoSoundElement_initClass", _wrap_SoSoundElement_initClass, METH_NOARGS, "SoSoundElement_initClass()"},
	 { "SoSoundElement_init", _wrap_SoSoundElement_init, METH_VARARGS, "SoSoundElement_init(SoSoundElement self, SoState state)"},
	 { "SoSoundElement_set", _wrap_SoSoundElement_set, METH_VARARGS, "SoSoundElement_set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"},
	 { "SoSoundElement_setSceneGraphHasSoundNode", _wrap_SoSoundElement_setSceneGraphHasSoundNode, METH_VARARGS, "SoSoundElement_setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"},
	 { "SoSoundElement_sceneGraphHasSoundNode", _wrap_SoSoundElement_sceneGraphHasSoundNode, METH_O, "SoSoundElement_sceneGraphHasSoundNode(SoState state) -> SbBool"},
	 { "SoSoundElement_setSoundNodeIsPlaying", _wrap_SoSoundElement_setSoundNodeIsPlaying, METH_VARARGS, "SoSoundElement_setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"},
	 { "SoSoundElement_soundNodeIsPlaying", _wrap_SoSoundElement_soundNodeIsPlaying, METH_O, "SoSoundElement_soundNodeIsPlaying(SoState state) -> SbBool"},
	 { "SoSoundElement_setIsPartOfActiveSceneGraph", _wrap_SoSoundElement_setIsPartOfActiveSceneGraph, METH_VARARGS, "SoSoundElement_setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"},
	 { "SoSoundElement_isPartOfActiveSceneGraph", _wrap_SoSoundElement_isPartOfActiveSceneGraph, METH_O, "SoSoundElement_isPartOfActiveSceneGraph(SoState state) -> SbBool"},
	 { "SoSoundElement_push", _wrap_SoSoundElement_push, METH_VARARGS, "SoSoundElement_push(SoSoundElement self, SoState state)"},
	 { "SoSoundElement_pop", _wrap_SoSoundElement_pop, METH_VARARGS, "SoSoundElement_pop(SoSoundElement self, SoState state, SoElement prevTopElement)"},
	 { "SoSoundElement_output", _wrap_SoSoundElement_output, METH_VARARGS, "SoSoundElement_output(SoSoundElement self, FILE * file)"},
	 { "SoSoundElement_swigregister", SoSoundElement_swigregister, METH_O, NULL},
	 { "SoGLVBOElement_getClassTypeId", _wrap_SoGLVBOElement_getClassTypeId, METH_NOARGS, "SoGLVBOElement_getClassTypeId() -> SoType"},
	 { "SoGLVBOElement_getClassStackIndex", _wrap_SoGLVBOElement_getClassStackIndex, METH_NOARGS, "SoGLVBOElement_getClassStackIndex() -> int"},
	 { "SoGLVBOElement_createInstance", _wrap_SoGLVBOElement_createInstance, METH_NOARGS, "SoGLVBOElement_createInstance() -> void *"},
	 { "SoGLVBOElement_initClass", _wrap_SoGLVBOElement_initClass, METH_NOARGS, "SoGLVBOElement_initClass()"},
	 { "SoGLVBOElement_shouldCreateVBO", _wrap_SoGLVBOElement_shouldCreateVBO, METH_VARARGS, "SoGLVBOElement_shouldCreateVBO(SoState state, int const numdata) -> SbBool"},
	 { "SoGLVBOElement_setVertexVBO", _wrap_SoGLVBOElement_setVertexVBO, METH_VARARGS, "SoGLVBOElement_setVertexVBO(SoState state, SoVBO * vbo)"},
	 { "SoGLVBOElement_setNormalVBO", _wrap_SoGLVBOElement_setNormalVBO, METH_VARARGS, "SoGLVBOElement_setNormalVBO(SoState state, SoVBO * vbo)"},
	 { "SoGLVBOElement_setColorVBO", _wrap_SoGLVBOElement_setColorVBO, METH_VARARGS, "SoGLVBOElement_setColorVBO(SoState state, SoVBO * vbo)"},
	 { "SoGLVBOElement_setTexCoordVBO", _wrap_SoGLVBOElement_setTexCoordVBO, METH_VARARGS, "SoGLVBOElement_setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"},
	 { "SoGLVBOElement_getInstance", _wrap_SoGLVBOElement_getInstance, METH_O, "SoGLVBOElement_getInstance(SoState state) -> SoGLVBOElement"},
	 { "SoGLVBOElement_init", _wrap_SoGLVBOElement_init, METH_VARARGS, "SoGLVBOElement_init(SoGLVBOElement self, SoState state)"},
	 { "SoGLVBOElement_push", _wrap_SoGLVBOElement_push, METH_VARARGS, "SoGLVBOElement_push(SoGLVBOElement self, SoState state)"},
	 { "SoGLVBOElement_pop", _wrap_SoGLVBOElement_pop, METH_VARARGS, "SoGLVBOElement_pop(SoGLVBOElement self, SoState state, SoElement prevtopelement)"},
	 { "SoGLVBOElement_matches", _wrap_SoGLVBOElement_matches, METH_VARARGS, "SoGLVBOElement_matches(SoGLVBOElement self, SoElement elt) -> SbBool"},
	 { "SoGLVBOElement_copyMatchInfo", _wrap_SoGLVBOElement_copyMatchInfo, METH_O, "SoGLVBOElement_copyMatchInfo(SoGLVBOElement self) -> SoElement"},
	 { "SoGLVBOElement_getVertexVBO", _wrap_SoGLVBOElement_getVertexVBO, METH_O, "SoGLVBOElement_getVertexVBO(SoGLVBOElement self) -> SoVBO *"},
	 { "SoGLVBOElement_getNormalVBO", _wrap_SoGLVBOElement_getNormalVBO, METH_O, "SoGLVBOElement_getNormalVBO(SoGLVBOElement self) -> SoVBO *"},
	 { "SoGLVBOElement_getColorVBO", _wrap_SoGLVBOElement_getColorVBO, METH_O, "SoGLVBOElement_getColorVBO(SoGLVBOElement self) -> SoVBO *"},
	 { "SoGLVBOElement_getNumTexCoordVBO", _wrap_SoGLVBOElement_getNumTexCoordVBO, METH_O, "SoGLVBOElement_getNumTexCoordVBO(SoGLVBOElement self) -> int"},
	 { "SoGLVBOElement_getTexCoordVBO", _wrap_SoGLVBOElement_getTexCoordVBO, METH_VARARGS, "SoGLVBOElement_getTexCoordVBO(SoGLVBOElement self, int const idx) -> SoVBO *"},
	 { "SoGLVBOElement_swigregister", SoGLVBOElement_swigregister, METH_O, NULL},
	 { "SoDepthBufferElement_getClassTypeId", _wrap_SoDepthBufferElement_getClassTypeId, METH_NOARGS, "SoDepthBufferElement_getClassTypeId() -> SoType"},
	 { "SoDepthBufferElement_getClassStackIndex", _wrap_SoDepthBufferElement_getClassStackIndex, METH_NOARGS, "SoDepthBufferElement_getClassStackIndex() -> int"},
	 { "SoDepthBufferElement_createInstance", _wrap_SoDepthBufferElement_createInstance, METH_NOARGS, "SoDepthBufferElement_createInstance() -> void *"},
	 { "SoDepthBufferElement_initClass", _wrap_SoDepthBufferElement_initClass, METH_NOARGS, "SoDepthBufferElement_initClass()"},
	 { "SoDepthBufferElement_set", _wrap_SoDepthBufferElement_set, METH_VARARGS, "SoDepthBufferElement_set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"},
	 { "SoDepthBufferElement_get", _wrap_SoDepthBufferElement_get, METH_VARARGS, "SoDepthBufferElement_get(SoState state, SbBool & test_out, SbBool & write_out, SoDepthBufferElement::DepthWriteFunction & function_out, SbVec2f range_out)"},
	 { "SoDepthBufferElement_getTestEnable", _wrap_SoDepthBufferElement_getTestEnable, METH_O, "SoDepthBufferElement_getTestEnable(SoState state) -> SbBool"},
	 { "SoDepthBufferElement_getWriteEnable", _wrap_SoDepthBufferElement_getWriteEnable, METH_O, "SoDepthBufferElement_getWriteEnable(SoState state) -> SbBool"},
	 { "SoDepthBufferElement_getFunction", _wrap_SoDepthBufferElement_getFunction, METH_O, "SoDepthBufferElement_getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"},
	 { "SoDepthBufferElement_getRange", _wrap_SoDepthBufferElement_getRange, METH_O, "SoDepthBufferElement_getRange(SoState state) -> SbVec2f"},
	 { "SoDepthBufferElement_init", _wrap_SoDepthBufferElement_init, METH_VARARGS, "SoDepthBufferElement_init(SoDepthBufferElement self, SoState state)"},
	 { "SoDepthBufferElement_push", _wrap_SoDepthBufferElement_push, METH_VARARGS, "SoDepthBufferElement_push(SoDepthBufferElement self, SoState state)"},
	 { "SoDepthBufferElement_pop", _wrap_SoDepthBufferElement_pop, METH_VARARGS, "SoDepthBufferElement_pop(SoDepthBufferElement self, SoState state, SoElement prevTopElement)"},
	 { "SoDepthBufferElement_matches", _wrap_SoDepthBufferElement_matches, METH_VARARGS, "SoDepthBufferElement_matches(SoDepthBufferElement self, SoElement element) -> SbBool"},
	 { "SoDepthBufferElement_copyMatchInfo", _wrap_SoDepthBufferElement_copyMatchInfo, METH_O, "SoDepthBufferElement_copyMatchInfo(SoDepthBufferElement self) -> SoElement"},
	 { "SoDepthBufferElement_swigregister", SoDepthBufferElement_swigregister, METH_O, NULL},
	 { "SoGLDepthBufferElement_getClassTypeId", _wrap_SoGLDepthBufferElement_getClassTypeId, METH_NOARGS, "SoGLDepthBufferElement_getClassTypeId() -> SoType"},
	 { "SoGLDepthBufferElement_getClassStackIndex", _wrap_SoGLDepthBufferElement_getClassStackIndex, METH_NOARGS, "SoGLDepthBufferElement_getClassStackIndex() -> int"},
	 { "SoGLDepthBufferElement_createInstance", _wrap_SoGLDepthBufferElement_createInstance, METH_NOARGS, "SoGLDepthBufferElement_createInstance() -> void *"},
	 { "SoGLDepthBufferElement_initClass", _wrap_SoGLDepthBufferElement_initClass, METH_NOARGS, "SoGLDepthBufferElement_initClass()"},
	 { "SoGLDepthBufferElement_init", _wrap_SoGLDepthBufferElement_init, METH_VARARGS, "SoGLDepthBufferElement_init(SoGLDepthBufferElement self, SoState state)"},
	 { "SoGLDepthBufferElement_push", _wrap_SoGLDepthBufferElement_push, METH_VARARGS, "SoGLDepthBufferElement_push(SoGLDepthBufferElement self, SoState state)"},
	 { "SoGLDepthBufferElement_pop", _wrap_SoGLDepthBufferElement_pop, METH_VARARGS, "SoGLDepthBufferElement_pop(SoGLDepthBufferElement self, SoState state, SoElement prevTopElement)"},
	 { "SoGLDepthBufferElement_swigregister", SoGLDepthBufferElement_swigregister, METH_O, NULL},
	 { "SoVertexAttributeElement_getClassTypeId", _wrap_SoVertexAttributeElement_getClassTypeId, METH_NOARGS, "SoVertexAttributeElement_getClassTypeId() -> SoType"},
	 { "SoVertexAttributeElement_getClassStackIndex", _wrap_SoVertexAttributeElement_getClassStackIndex, METH_NOARGS, "SoVertexAttributeElement_getClassStackIndex() -> int"},
	 { "SoVertexAttributeElement_createInstance", _wrap_SoVertexAttributeElement_createInstance, METH_NOARGS, "SoVertexAttributeElement_createInstance() -> void *"},
	 { "SoVertexAttributeElement_initClass", _wrap_SoVertexAttributeElement_initClass, METH_NOARGS, "SoVertexAttributeElement_initClass()"},
	 { "SoVertexAttributeElement_init", _wrap_SoVertexAttributeElement_init, METH_VARARGS, "SoVertexAttributeElement_init(SoVertexAttributeElement self, SoState state)"},
	 { "SoVertexAttributeElement_push", _wrap_SoVertexAttributeElement_push, METH_VARARGS, "SoVertexAttributeElement_push(SoVertexAttributeElement self, SoState state)"},
	 { "SoVertexAttributeElement_add", _wrap_SoVertexAttributeElement_add, METH_VARARGS, "SoVertexAttributeElement_add(SoState state, SoVertexAttributeData * attribdata)"},
	 { "SoVertexAttributeElement_getInstance", _wrap_SoVertexAttributeElement_getInstance, METH_O, "SoVertexAttributeElement_getInstance(SoState state) -> SoVertexAttributeElement"},
	 { "SoVertexAttributeElement_getNumAttributes", _wrap_SoVertexAttributeElement_getNumAttributes, METH_O, "SoVertexAttributeElement_getNumAttributes(SoVertexAttributeElement self) -> unsigned int"},
	 { "SoVertexAttributeElement_applyToAttributes", _wrap_SoVertexAttributeElement_applyToAttributes, METH_VARARGS, "SoVertexAttributeElement_applyToAttributes(SoVertexAttributeElement self, SoVertexAttributeElement::AttributeApplyFunc * func, void * closure)"},
	 { "SoVertexAttributeElement_swigregister", SoVertexAttributeElement_swigregister, METH_O, NULL},
	 { "SoGLVertexAttributeElement_getClassTypeId", _wrap_SoGLVertexAttributeElement_getClassTypeId, METH_NOARGS, "SoGLVertexAttributeElement_getClassTypeId() -> SoType"},
	 { "SoGLVertexAttributeElement_getClassStackIndex", _wrap_SoGLVertexAttributeElement_getClassStackIndex, METH_NOARGS, "SoGLVertexAttributeElement_getClassStackIndex() -> int"},
	 { "SoGLVertexAttributeElement_createInstance", _wrap_SoGLVertexAttributeElement_createInstance, METH_NOARGS, "SoGLVertexAttributeElement_createInstance() -> void *"},
	 { "SoGLVertexAttributeElement_initClass", _wrap_SoGLVertexAttributeElement_initClass, METH_NOARGS, "SoGLVertexAttributeElement_initClass()"},
	 { "SoGLVertexAttributeElement_init", _wrap_SoGLVertexAttributeElement_init, METH_VARARGS, "SoGLVertexAttributeElement_init(SoGLVertexAttributeElement self, SoState state)"},
	 { "SoGLVertexAttributeElement_enableVBO", _wrap_SoGLVertexAttributeElement_enableVBO, METH_VARARGS, "SoGLVertexAttributeElement_enableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"},
	 { "SoGLVertexAttributeElement_disableVBO", _wrap_SoGLVertexAttributeElement_disableVBO, METH_VARARGS, "SoGLVertexAttributeElement_disableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"},
	 { "SoGLVertexAttributeElement_send", _wrap_SoGLVertexAttributeElement_send, METH_VARARGS, "SoGLVertexAttributeElement_send(SoGLVertexAttributeElement self, int const index)"},
	 { "SoGLVertexAttributeElement_getInstance", _wrap_SoGLVertexAttributeElement_getInstance, METH_O, "SoGLVertexAttributeElement_getInstance(SoState state) -> SoGLVertexAttributeElement"},
	 { "SoGLVertexAttributeElement_swigregister", SoGLVertexAttributeElement_swigregister, METH_O, NULL},
	 { "SoVertexAttributeBindingElement_getClassTypeId", _wrap_SoVertexAttributeBindingElement_getClassTypeId, METH_NOARGS, "SoVertexAttributeBindingElement_getClassTypeId() -> SoType"},
	 { "SoVertexAttributeBindingElement_getClassStackIndex", _wrap_SoVertexAttributeBindingElement_getClassStackIndex, METH_NOARGS, "SoVertexAttributeBindingElement_getClassStackIndex() -> int"},
	 { "SoVertexAttributeBindingElement_createInstance", _wrap_SoVertexAttributeBindingElement_createInstance, METH_NOARGS, "SoVertexAttributeBindingElement_createInstance() -> void *"},
	 { "SoVertexAttributeBindingElement_initClass", _wrap_SoVertexAttributeBindingElement_initClass, METH_NOARGS, "SoVertexAttributeBindingElement_initClass()"},
	 { "SoVertexAttributeBindingElement_init", _wrap_SoVertexAttributeBindingElement_init, METH_VARARGS, "SoVertexAttributeBindingElement_init(SoVertexAttributeBindingElement self, SoState state)"},
	 { "SoVertexAttributeBindingElement_set", _wrap_SoVertexAttributeBindingElement_set, METH_VARARGS, "\n"
		"SoVertexAttributeBindingElement_set(SoState state, SoNode node, SoVertexAttributeBindingElement::Binding const binding)\n"
		"SoVertexAttributeBindingElement_set(SoState state, SoVertexAttributeBindingElement::Binding const binding)\n"
		""},
	 { "SoVertexAttributeBindingElement_get", _wrap_SoVertexAttributeBindingElement_get, METH_O, "SoVertexAttributeBindingElement_get(SoState state) -> SoVertexAttributeBindingElement::Binding"},
	 { "SoVertexAttributeBindingElement_getDefault", _wrap_SoVertexAttributeBindingElement_getDefault, METH_NOARGS, "SoVertexAttributeBindingElement_getDefault() -> SoVertexAttributeBindingElement::Binding"},
	 { "SoVertexAttributeBindingElement_swigregister", SoVertexAttributeBindingElement_swigregister, METH_O, NULL},
	 { "SoSpecularColorElement_getClassTypeId", _wrap_SoSpecularColorElement_getClassTypeId, METH_NOARGS, "SoSpecularColorElement_getClassTypeId() -> SoType"},
	 { "SoSpecularColorElement_getClassStackIndex", _wrap_SoSpecularColorElement_getClassStackIndex, METH_NOARGS, "SoSpecularColorElement_getClassStackIndex() -> int"},
	 { "SoSpecularColorElement_createInstance", _wrap_SoSpecularColorElement_createInstance, METH_NOARGS, "SoSpecularColorElement_createInstance() -> void *"},
	 { "SoSpecularColorElement_initClass", _wrap_SoSpecularColorElement_initClass, METH_NOARGS, "SoSpecularColorElement_initClass()"},
	 { "SoSpecularColorElement_init", _wrap_SoSpecularColorElement_init, METH_VARARGS, "SoSpecularColorElement_init(SoSpecularColorElement self, SoState state)"},
	 { "SoSpecularColorElement_set", _wrap_SoSpecularColorElement_set, METH_VARARGS, "SoSpecularColorElement_set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"},
	 { "SoSpecularColorElement_getInstance", _wrap_SoSpecularColorElement_getInstance, METH_O, "SoSpecularColorElement_getInstance(SoState state) -> SoSpecularColorElement"},
	 { "SoSpecularColorElement_getNum", _wrap_SoSpecularColorElement_getNum, METH_O, "SoSpecularColorElement_getNum(SoSpecularColorElement self) -> int32_t"},
	 { "SoSpecularColorElement_get", _wrap_SoSpecularColorElement_get, METH_VARARGS, "SoSpecularColorElement_get(SoSpecularColorElement self, int const index) -> SbColor"},
	 { "SoSpecularColorElement_getArrayPtr", _wrap_SoSpecularColorElement_getArrayPtr, METH_O, "SoSpecularColorElement_getArrayPtr(SoSpecularColorElement self) -> SbColor"},
	 { "SoSpecularColorElement_swigregister", SoSpecularColorElement_swigregister, METH_O, NULL},
	 { "SoEmissiveColorElement_getClassTypeId", _wrap_SoEmissiveColorElement_getClassTypeId, METH_NOARGS, "SoEmissiveColorElement_getClassTypeId() -> SoType"},
	 { "SoEmissiveColorElement_getClassStackIndex", _wrap_SoEmissiveColorElement_getClassStackIndex, METH_NOARGS, "SoEmissiveColorElement_getClassStackIndex() -> int"},
	 { "SoEmissiveColorElement_createInstance", _wrap_SoEmissiveColorElement_createInstance, METH_NOARGS, "SoEmissiveColorElement_createInstance() -> void *"},
	 { "SoEmissiveColorElement_initClass", _wrap_SoEmissiveColorElement_initClass, METH_NOARGS, "SoEmissiveColorElement_initClass()"},
	 { "SoEmissiveColorElement_init", _wrap_SoEmissiveColorElement_init, METH_VARARGS, "SoEmissiveColorElement_init(SoEmissiveColorElement self, SoState state)"},
	 { "SoEmissiveColorElement_set", _wrap_SoEmissiveColorElement_set, METH_VARARGS, "SoEmissiveColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"},
	 { "SoEmissiveColorElement_getInstance", _wrap_SoEmissiveColorElement_getInstance, METH_O, "SoEmissiveColorElement_getInstance(SoState state) -> SoEmissiveColorElement"},
	 { "SoEmissiveColorElement_getNum", _wrap_SoEmissiveColorElement_getNum, METH_O, "SoEmissiveColorElement_getNum(SoEmissiveColorElement self) -> int32_t"},
	 { "SoEmissiveColorElement_get", _wrap_SoEmissiveColorElement_get, METH_VARARGS, "SoEmissiveColorElement_get(SoEmissiveColorElement self, int const index) -> SbColor"},
	 { "SoEmissiveColorElement_getArrayPtr", _wrap_SoEmissiveColorElement_getArrayPtr, METH_O, "SoEmissiveColorElement_getArrayPtr(SoEmissiveColorElement self) -> SbColor"},
	 { "SoEmissiveColorElement_swigregister", SoEmissiveColorElement_swigregister, METH_O, NULL},
	 { "SoShininessElement_getClassTypeId", _wrap_SoShininessElement_getClassTypeId, METH_NOARGS, "SoShininessElement_getClassTypeId() -> SoType"},
	 { "SoShininessElement_getClassStackIndex", _wrap_SoShininessElement_getClassStackIndex, METH_NOARGS, "SoShininessElement_getClassStackIndex() -> int"},
	 { "SoShininessElement_createInstance", _wrap_SoShininessElement_createInstance, METH_NOARGS, "SoShininessElement_createInstance() -> void *"},
	 { "SoShininessElement_initClass", _wrap_SoShininessElement_initClass, METH_NOARGS, "SoShininessElement_initClass()"},
	 { "SoShininessElement_init", _wrap_SoShininessElement_init, METH_VARARGS, "SoShininessElement_init(SoShininessElement self, SoState state)"},
	 { "SoShininessElement_set", _wrap_SoShininessElement_set, METH_VARARGS, "SoShininessElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"},
	 { "SoShininessElement_getInstance", _wrap_SoShininessElement_getInstance, METH_O, "SoShininessElement_getInstance(SoState state) -> SoShininessElement"},
	 { "SoShininessElement_getNum", _wrap_SoShininessElement_getNum, METH_O, "SoShininessElement_getNum(SoShininessElement self) -> int32_t"},
	 { "SoShininessElement_get", _wrap_SoShininessElement_get, METH_VARARGS, "SoShininessElement_get(SoShininessElement self, int const index) -> float"},
	 { "SoShininessElement_getArrayPtr", _wrap_SoShininessElement_getArrayPtr, METH_O, "SoShininessElement_getArrayPtr(SoShininessElement self) -> float const *"},
	 { "SoShininessElement_swigregister", SoShininessElement_swigregister, METH_O, NULL},
	 { "SoTransparencyElement_getClassTypeId", _wrap_SoTransparencyElement_getClassTypeId, METH_NOARGS, "SoTransparencyElement_getClassTypeId() -> SoType"},
	 { "SoTransparencyElement_getClassStackIndex", _wrap_SoTransparencyElement_getClassStackIndex, METH_NOARGS, "SoTransparencyElement_getClassStackIndex() -> int"},
	 { "SoTransparencyElement_createInstance", _wrap_SoTransparencyElement_createInstance, METH_NOARGS, "SoTransparencyElement_createInstance() -> void *"},
	 { "SoTransparencyElement_initClass", _wrap_SoTransparencyElement_initClass, METH_NOARGS, "SoTransparencyElement_initClass()"},
	 { "SoTransparencyElement_init", _wrap_SoTransparencyElement_init, METH_VARARGS, "SoTransparencyElement_init(SoTransparencyElement self, SoState state)"},
	 { "SoTransparencyElement_set", _wrap_SoTransparencyElement_set, METH_VARARGS, "SoTransparencyElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"},
	 { "SoTransparencyElement_getInstance", _wrap_SoTransparencyElement_getInstance, METH_O, "SoTransparencyElement_getInstance(SoState state) -> SoTransparencyElement"},
	 { "SoTransparencyElement_getNum", _wrap_SoTransparencyElement_getNum, METH_O, "SoTransparencyElement_getNum(SoTransparencyElement self) -> int32_t"},
	 { "SoTransparencyElement_get", _wrap_SoTransparencyElement_get, METH_VARARGS, "SoTransparencyElement_get(SoTransparencyElement self, int const index) -> float"},
	 { "SoTransparencyElement_getArrayPtr", _wrap_SoTransparencyElement_getArrayPtr, METH_O, "SoTransparencyElement_getArrayPtr(SoTransparencyElement self) -> float const *"},
	 { "SoTransparencyElement_swigregister", SoTransparencyElement_swigregister, METH_O, NULL},
	 { "SoLightModelElement_getClassTypeId", _wrap_SoLightModelElement_getClassTypeId, METH_NOARGS, "SoLightModelElement_getClassTypeId() -> SoType"},
	 { "SoLightModelElement_getClassStackIndex", _wrap_SoLightModelElement_getClassStackIndex, METH_NOARGS, "SoLightModelElement_getClassStackIndex() -> int"},
	 { "SoLightModelElement_createInstance", _wrap_SoLightModelElement_createInstance, METH_NOARGS, "SoLightModelElement_createInstance() -> void *"},
	 { "SoLightModelElement_initClass", _wrap_SoLightModelElement_initClass, METH_NOARGS, "SoLightModelElement_initClass()"},
	 { "SoLightModelElement_init", _wrap_SoLightModelElement_init, METH_VARARGS, "SoLightModelElement_init(SoLightModelElement self, SoState state)"},
	 { "SoLightModelElement_set", _wrap_SoLightModelElement_set, METH_VARARGS, "\n"
		"SoLightModelElement_set(SoState state, SoLightModelElement::Model const model)\n"
		"SoLightModelElement_set(SoState state, SoNode node, SoLightModelElement::Model const model)\n"
		""},
	 { "SoLightModelElement_get", _wrap_SoLightModelElement_get, METH_O, "SoLightModelElement_get(SoState state) -> SoLightModelElement::Model"},
	 { "SoLightModelElement_getDefault", _wrap_SoLightModelElement_getDefault, METH_NOARGS, "SoLightModelElement_getDefault() -> SoLightModelElement::Model"},
	 { "SoLightModelElement_getInstance", _wrap_SoLightModelElement_getInstance, METH_O, "SoLightModelElement_getInstance(SoState state) -> SoLightModelElement"},
	 { "SoLightModelElement_swigregister", SoLightModelElement_swigregister, METH_O, NULL},
	 { "new_SbColor4f", _wrap_new_SbColor4f, METH_VARARGS, "\n"
		"SbColor4f()\n"
		"SbColor4f(SbColor rgb, float const alpha=1.0)\n"
		"SbColor4f(SbVec4f v)\n"
		"SbColor4f(float const *const rgba)\n"
		"SbColor4f(float const r, float const g, float const b, float const a=1.0)\n"
		""},
	 { "SbColor4f_setValue", _wrap_SbColor4f_setValue, METH_VARARGS, "\n"
		"SbColor4f_setValue(SbColor4f self, float const r, float const g, float const b, float const a=1.0)\n"
		"SbColor4f_setValue(SbColor4f self, float const [4] col)\n"
		""},
	 { "SbColor4f_getValue", _wrap_SbColor4f_getValue, METH_O, "SbColor4f_getValue(SbColor4f self)"},
	 { "SbColor4f_setRGB", _wrap_SbColor4f_setRGB, METH_VARARGS, "SbColor4f_setRGB(SbColor4f self, SbColor col) -> SbColor4f"},
	 { "SbColor4f_getRGB", _wrap_SbColor4f_getRGB, METH_VARARGS, "SbColor4f_getRGB(SbColor4f self, SbColor color)"},
	 { "SbColor4f_setHSVValue", _wrap_SbColor4f_setHSVValue, METH_VARARGS, "\n"
		"SbColor4f_setHSVValue(SbColor4f self, float h, float s, float v, float a=1.0) -> SbColor4f\n"
		"SbColor4f_setHSVValue(SbColor4f self, float const [3] hsv, float alpha=1.0) -> SbColor4f\n"
		""},
	 { "SbColor4f_getHSVValue", _wrap_SbColor4f_getHSVValue, METH_O, "SbColor4f_getHSVValue(SbColor4f self)"},
	 { "SbColor4f_setPackedValue", _wrap_SbColor4f_setPackedValue, METH_VARARGS, "SbColor4f_setPackedValue(SbColor4f self, uint32_t const rgba) -> SbColor4f"},
	 { "SbColor4f_getPackedValue", _wrap_SbColor4f_getPackedValue, METH_O, "SbColor4f_getPackedValue(SbColor4f self) -> uint32_t"},
	 { "SbColor4f___imul__", _wrap_SbColor4f___imul__, METH_VARARGS, "SbColor4f___imul__(SbColor4f self, float const d) -> SbColor4f"},
	 { "SbColor4f___itruediv__", _wrap_SbColor4f___itruediv__, METH_VARARGS, "SbColor4f___itruediv__(SbColor4f self, float const d) -> SbColor4f"},
	 { "SbColor4f___iadd__", _wrap_SbColor4f___iadd__, METH_VARARGS, "SbColor4f___iadd__(SbColor4f self, SbColor4f c) -> SbColor4f"},
	 { "SbColor4f___isub__", _wrap_SbColor4f___isub__, METH_VARARGS, "SbColor4f___isub__(SbColor4f self, SbColor4f c) -> SbColor4f"},
	 { "SbColor4f___add__", _wrap_SbColor4f___add__, METH_VARARGS, "SbColor4f___add__(SbColor4f self, SbColor4f u) -> SbColor4f"},
	 { "SbColor4f___sub__", _wrap_SbColor4f___sub__, METH_VARARGS, "SbColor4f___sub__(SbColor4f self, SbColor4f u) -> SbColor4f"},
	 { "SbColor4f___mul__", _wrap_SbColor4f___mul__, METH_VARARGS, "SbColor4f___mul__(SbColor4f self, float const d) -> SbColor4f"},
	 { "SbColor4f___rmul__", _wrap_SbColor4f___rmul__, METH_VARARGS, "SbColor4f___rmul__(SbColor4f self, float const d) -> SbColor4f"},
	 { "SbColor4f___div__", _wrap_SbColor4f___div__, METH_VARARGS, "SbColor4f___div__(SbColor4f self, float const d) -> SbColor4f"},
	 { "SbColor4f___eq__", _wrap_SbColor4f___eq__, METH_VARARGS, "SbColor4f___eq__(SbColor4f self, SbColor4f u) -> int"},
	 { "SbColor4f___nq__", _wrap_SbColor4f___nq__, METH_VARARGS, "SbColor4f___nq__(SbColor4f self, SbColor4f u) -> int"},
	 { "SbColor4f___getitem__", _wrap_SbColor4f___getitem__, METH_VARARGS, "SbColor4f___getitem__(SbColor4f self, int i) -> float"},
	 { "delete_SbColor4f", _wrap_delete_SbColor4f, METH_O, "delete_SbColor4f(SbColor4f self)"},
	 { "SbColor4f_swigregister", SbColor4f_swigregister, METH_O, NULL},
	 { "SbColor4f_swiginit", SbColor4f_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCombineElement_getClassTypeId", _wrap_SoTextureCombineElement_getClassTypeId, METH_NOARGS, "SoTextureCombineElement_getClassTypeId() -> SoType"},
	 { "SoTextureCombineElement_getClassStackIndex", _wrap_SoTextureCombineElement_getClassStackIndex, METH_NOARGS, "SoTextureCombineElement_getClassStackIndex() -> int"},
	 { "SoTextureCombineElement_createInstance", _wrap_SoTextureCombineElement_createInstance, METH_NOARGS, "SoTextureCombineElement_createInstance() -> void *"},
	 { "SoTextureCombineElement_initClass", _wrap_SoTextureCombineElement_initClass, METH_NOARGS, "SoTextureCombineElement_initClass()"},
	 { "SoTextureCombineElement_init", _wrap_SoTextureCombineElement_init, METH_VARARGS, "SoTextureCombineElement_init(SoTextureCombineElement self, SoState state)"},
	 { "SoTextureCombineElement_set", _wrap_SoTextureCombineElement_set, METH_VARARGS, "SoTextureCombineElement_set(SoState state, SoNode node, int const unit, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"},
	 { "SoTextureCombineElement_isDefault", _wrap_SoTextureCombineElement_isDefault, METH_VARARGS, "SoTextureCombineElement_isDefault(SoState state, int const unit) -> SbBool"},
	 { "SoTextureCombineElement_get", _wrap_SoTextureCombineElement_get, METH_VARARGS, "SoTextureCombineElement_get(SoState state, int const unit, SoTextureCombineElement::Operation & rgboperation, SoTextureCombineElement::Operation & alphaoperation, SoTextureCombineElement::Source * rgbsource, SoTextureCombineElement::Source * alphasource, SoTextureCombineElement::Operand * rgboperand, SoTextureCombineElement::Operand * alphaoperand, SbColor4f constantcolor, float & rgbscale, float & alphascale)"},
	 { "SoTextureCombineElement_push", _wrap_SoTextureCombineElement_push, METH_VARARGS, "SoTextureCombineElement_push(SoTextureCombineElement self, SoState state)"},
	 { "SoTextureCombineElement_matches", _wrap_SoTextureCombineElement_matches, METH_VARARGS, "SoTextureCombineElement_matches(SoTextureCombineElement self, SoElement elem) -> SbBool"},
	 { "SoTextureCombineElement_copyMatchInfo", _wrap_SoTextureCombineElement_copyMatchInfo, METH_O, "SoTextureCombineElement_copyMatchInfo(SoTextureCombineElement self) -> SoElement"},
	 { "SoTextureCombineElement_setElt", _wrap_SoTextureCombineElement_setElt, METH_VARARGS, "SoTextureCombineElement_setElt(SoTextureCombineElement self, int const unit, SbUniqueId const nodeid, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"},
	 { "SoTextureCombineElement_apply", _wrap_SoTextureCombineElement_apply, METH_VARARGS, "SoTextureCombineElement_apply(SoState state, int const unit)"},
	 { "SoTextureCombineElement_swigregister", SoTextureCombineElement_swigregister, METH_O, NULL},
	 { "SoTextureUnitElement_getClassTypeId", _wrap_SoTextureUnitElement_getClassTypeId, METH_NOARGS, "SoTextureUnitElement_getClassTypeId() -> SoType"},
	 { "SoTextureUnitElement_getClassStackIndex", _wrap_SoTextureUnitElement_getClassStackIndex, METH_NOARGS, "SoTextureUnitElement_getClassStackIndex() -> int"},
	 { "SoTextureUnitElement_createInstance", _wrap_SoTextureUnitElement_createInstance, METH_NOARGS, "SoTextureUnitElement_createInstance() -> void *"},
	 { "SoTextureUnitElement_initClass", _wrap_SoTextureUnitElement_initClass, METH_NOARGS, "SoTextureUnitElement_initClass()"},
	 { "SoTextureUnitElement_init", _wrap_SoTextureUnitElement_init, METH_VARARGS, "SoTextureUnitElement_init(SoTextureUnitElement self, SoState state)"},
	 { "SoTextureUnitElement_set", _wrap_SoTextureUnitElement_set, METH_VARARGS, "SoTextureUnitElement_set(SoState state, SoNode node, int const units)"},
	 { "SoTextureUnitElement_get", _wrap_SoTextureUnitElement_get, METH_O, "SoTextureUnitElement_get(SoState state) -> int"},
	 { "SoTextureUnitElement_swigregister", SoTextureUnitElement_swigregister, METH_O, NULL},
	 { "SoEngine_initClass", _wrap_SoEngine_initClass, METH_NOARGS, "SoEngine_initClass()"},
	 { "SoEngine_initClasses", _wrap_SoEngine_initClasses, METH_NOARGS, "SoEngine_initClasses()"},
	 { "SoEngine_getClassTypeId", _wrap_SoEngine_getClassTypeId, METH_NOARGS, "SoEngine_getClassTypeId() -> SoType"},
	 { "SoEngine_evaluateWrapper", _wrap_SoEngine_evaluateWrapper, METH_O, "SoEngine_evaluateWrapper(SoEngine self)"},
	 { "SoEngine_getOutputs", _wrap_SoEngine_getOutputs, METH_VARARGS, "SoEngine_getOutputs(SoEngine self, SoEngineOutputList l) -> int"},
	 { "SoEngine_getOutput", _wrap_SoEngine_getOutput, METH_VARARGS, "SoEngine_getOutput(SoEngine self, SbName outputname) -> SoEngineOutput"},
	 { "SoEngine_getOutputName", _wrap_SoEngine_getOutputName, METH_VARARGS, "SoEngine_getOutputName(SoEngine self, SoEngineOutput output, SbName outputname) -> SbBool"},
	 { "SoEngine_getOutputData", _wrap_SoEngine_getOutputData, METH_O, "SoEngine_getOutputData(SoEngine self) -> SoEngineOutputData"},
	 { "SoEngine_getByName", _wrap_SoEngine_getByName, METH_VARARGS, "\n"
		"SoEngine_getByName(SbName name) -> SoEngine\n"
		"SoEngine_getByName(SbName name, SoEngineList el) -> int\n"
		""},
	 { "SoEngine_isNotifying", _wrap_SoEngine_isNotifying, METH_O, "SoEngine_isNotifying(SoEngine self) -> SbBool"},
	 { "SoEngine_notify", _wrap_SoEngine_notify, METH_VARARGS, "SoEngine_notify(SoEngine self, SoNotList nl)"},
	 { "SoEngine_copy", _wrap_SoEngine_copy, METH_O, "SoEngine_copy(SoEngine self) -> SoEngine"},
	 { "SoEngine_copyThroughConnection", _wrap_SoEngine_copyThroughConnection, METH_O, "SoEngine_copyThroughConnection(SoEngine self) -> SoFieldContainer"},
	 { "SoEngine_shouldCopy", _wrap_SoEngine_shouldCopy, METH_O, "SoEngine_shouldCopy(SoEngine self) -> SbBool"},
	 { "SoEngine_writeInstance", _wrap_SoEngine_writeInstance, METH_VARARGS, "SoEngine_writeInstance(SoEngine self, SoOutput out)"},
	 { "SoEngine_swigregister", SoEngine_swigregister, METH_O, NULL},
	 { "new_SoEngineOutput", _wrap_new_SoEngineOutput, METH_NOARGS, "new_SoEngineOutput() -> SoEngineOutput"},
	 { "delete_SoEngineOutput", _wrap_delete_SoEngineOutput, METH_O, "delete_SoEngineOutput(SoEngineOutput self)"},
	 { "SoEngineOutput_getConnectionType", _wrap_SoEngineOutput_getConnectionType, METH_O, "SoEngineOutput_getConnectionType(SoEngineOutput self) -> SoType"},
	 { "SoEngineOutput_getForwardConnections", _wrap_SoEngineOutput_getForwardConnections, METH_VARARGS, "SoEngineOutput_getForwardConnections(SoEngineOutput self, SoFieldList fl) -> int"},
	 { "SoEngineOutput_enable", _wrap_SoEngineOutput_enable, METH_VARARGS, "SoEngineOutput_enable(SoEngineOutput self, SbBool const flag)"},
	 { "SoEngineOutput_isEnabled", _wrap_SoEngineOutput_isEnabled, METH_O, "SoEngineOutput_isEnabled(SoEngineOutput self) -> SbBool"},
	 { "SoEngineOutput_getContainer", _wrap_SoEngineOutput_getContainer, METH_O, "SoEngineOutput_getContainer(SoEngineOutput self) -> SoEngine"},
	 { "SoEngineOutput_getNodeContainer", _wrap_SoEngineOutput_getNodeContainer, METH_O, "SoEngineOutput_getNodeContainer(SoEngineOutput self) -> SoNodeEngine"},
	 { "SoEngineOutput_isNodeEngineOutput", _wrap_SoEngineOutput_isNodeEngineOutput, METH_O, "SoEngineOutput_isNodeEngineOutput(SoEngineOutput self) -> SbBool"},
	 { "SoEngineOutput_setContainer", _wrap_SoEngineOutput_setContainer, METH_VARARGS, "SoEngineOutput_setContainer(SoEngineOutput self, SoEngine engine)"},
	 { "SoEngineOutput_setNodeContainer", _wrap_SoEngineOutput_setNodeContainer, METH_VARARGS, "SoEngineOutput_setNodeContainer(SoEngineOutput self, SoNodeEngine nodeengine)"},
	 { "SoEngineOutput_addConnection", _wrap_SoEngineOutput_addConnection, METH_VARARGS, "SoEngineOutput_addConnection(SoEngineOutput self, SoField f)"},
	 { "SoEngineOutput_removeConnection", _wrap_SoEngineOutput_removeConnection, METH_VARARGS, "SoEngineOutput_removeConnection(SoEngineOutput self, SoField f)"},
	 { "SoEngineOutput_getNumConnections", _wrap_SoEngineOutput_getNumConnections, METH_O, "SoEngineOutput_getNumConnections(SoEngineOutput self) -> int"},
	 { "SoEngineOutput_prepareToWrite", _wrap_SoEngineOutput_prepareToWrite, METH_O, "SoEngineOutput_prepareToWrite(SoEngineOutput self)"},
	 { "SoEngineOutput_doneWriting", _wrap_SoEngineOutput_doneWriting, METH_O, "SoEngineOutput_doneWriting(SoEngineOutput self)"},
	 { "SoEngineOutput_touchSlaves", _wrap_SoEngineOutput_touchSlaves, METH_VARARGS, "SoEngineOutput_touchSlaves(SoEngineOutput self, SoNotList nl, SbBool donotify)"},
	 { "SoEngineOutput_getFieldContainer", _wrap_SoEngineOutput_getFieldContainer, METH_O, "SoEngineOutput_getFieldContainer(SoEngineOutput self) -> SoFieldContainer"},
	 { "SoEngineOutput_swigregister", SoEngineOutput_swigregister, METH_O, NULL},
	 { "SoEngineOutput_swiginit", SoEngineOutput_swiginit, METH_VARARGS, NULL},
	 { "new_SoEngineOutputData", _wrap_new_SoEngineOutputData, METH_VARARGS, "\n"
		"SoEngineOutputData()\n"
		"SoEngineOutputData(SoEngineOutputData data)\n"
		"new_SoEngineOutputData(int approxnum) -> SoEngineOutputData\n"
		""},
	 { "delete_SoEngineOutputData", _wrap_delete_SoEngineOutputData, METH_O, "delete_SoEngineOutputData(SoEngineOutputData self)"},
	 { "SoEngineOutputData_addOutput", _wrap_SoEngineOutputData_addOutput, METH_VARARGS, "\n"
		"SoEngineOutputData_addOutput(SoEngineOutputData self, SoEngine base, char const * name, SoEngineOutput output, SoType type)\n"
		"SoEngineOutputData_addOutput(SoEngineOutputData self, SoNodeEngine base, char const * name, SoEngineOutput output, SoType type)\n"
		""},
	 { "SoEngineOutputData_getNumOutputs", _wrap_SoEngineOutputData_getNumOutputs, METH_O, "SoEngineOutputData_getNumOutputs(SoEngineOutputData self) -> int"},
	 { "SoEngineOutputData_getOutputName", _wrap_SoEngineOutputData_getOutputName, METH_VARARGS, "SoEngineOutputData_getOutputName(SoEngineOutputData self, int index) -> SbName"},
	 { "SoEngineOutputData_getOutput", _wrap_SoEngineOutputData_getOutput, METH_VARARGS, "\n"
		"SoEngineOutputData_getOutput(SoEngineOutputData self, SoEngine engine, int index) -> SoEngineOutput\n"
		"SoEngineOutputData_getOutput(SoEngineOutputData self, SoNodeEngine engine, int index) -> SoEngineOutput\n"
		""},
	 { "SoEngineOutputData_getIndex", _wrap_SoEngineOutputData_getIndex, METH_VARARGS, "\n"
		"SoEngineOutputData_getIndex(SoEngineOutputData self, SoEngine engine, SoEngineOutput output) -> int\n"
		"SoEngineOutputData_getIndex(SoEngineOutputData self, SoNodeEngine engine, SoEngineOutput output) -> int\n"
		""},
	 { "SoEngineOutputData_getType", _wrap_SoEngineOutputData_getType, METH_VARARGS, "SoEngineOutputData_getType(SoEngineOutputData self, int index) -> SoType"},
	 { "SoEngineOutputData_readDescriptions", _wrap_SoEngineOutputData_readDescriptions, METH_VARARGS, "SoEngineOutputData_readDescriptions(SoEngineOutputData self, SoInput input, SoEngine engine) -> SbBool"},
	 { "SoEngineOutputData_writeDescriptions", _wrap_SoEngineOutputData_writeDescriptions, METH_VARARGS, "SoEngineOutputData_writeDescriptions(SoEngineOutputData self, SoOutput out, SoEngine engine)"},
	 { "SoEngineOutputData_swigregister", SoEngineOutputData_swigregister, METH_O, NULL},
	 { "SoEngineOutputData_swiginit", SoEngineOutputData_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFBool", _wrap_new_SoMFBool, METH_NOARGS, "new_SoMFBool() -> SoMFBool"},
	 { "delete_SoMFBool", _wrap_delete_SoMFBool, METH_O, "delete_SoMFBool(SoMFBool self)"},
	 { "SoMFBool_createInstance", _wrap_SoMFBool_createInstance, METH_NOARGS, "SoMFBool_createInstance() -> void *"},
	 { "SoMFBool_getClassTypeId", _wrap_SoMFBool_getClassTypeId, METH_NOARGS, "SoMFBool_getClassTypeId() -> SoType"},
	 { "SoMFBool_getTypeId", _wrap_SoMFBool_getTypeId, METH_O, "SoMFBool_getTypeId(SoMFBool self) -> SoType"},
	 { "SoMFBool_copyFrom", _wrap_SoMFBool_copyFrom, METH_VARARGS, "SoMFBool_copyFrom(SoMFBool self, SoField field)"},
	 { "SoMFBool_isSame", _wrap_SoMFBool_isSame, METH_VARARGS, "SoMFBool_isSame(SoMFBool self, SoField field) -> SbBool"},
	 { "SoMFBool_find", _wrap_SoMFBool_find, METH_VARARGS, "SoMFBool_find(SoMFBool self, SbBool value, SbBool addifnotfound=0) -> int"},
	 { "SoMFBool_setValues", _wrap_SoMFBool_setValues, METH_VARARGS, "SoMFBool_setValues(SoMFBool self, int const start, int const num, SbBool const * newvals)"},
	 { "SoMFBool_set1Value", _wrap_SoMFBool_set1Value, METH_VARARGS, "SoMFBool_set1Value(SoMFBool self, int const idx, SbBool value)"},
	 { "SoMFBool___eq__", _wrap_SoMFBool___eq__, METH_VARARGS, "SoMFBool___eq__(SoMFBool self, SoMFBool field) -> SbBool"},
	 { "SoMFBool___ne__", _wrap_SoMFBool___ne__, METH_VARARGS, "SoMFBool___ne__(SoMFBool self, SoMFBool field) -> SbBool"},
	 { "SoMFBool_startEditing", _wrap_SoMFBool_startEditing, METH_O, "SoMFBool_startEditing(SoMFBool self) -> SbBool *"},
	 { "SoMFBool_finishEditing", _wrap_SoMFBool_finishEditing, METH_O, "SoMFBool_finishEditing(SoMFBool self)"},
	 { "SoMFBool_setValuesPointer", _wrap_SoMFBool_setValuesPointer, METH_VARARGS, "\n"
		"SoMFBool_setValuesPointer(SoMFBool self, int const num, SbBool const * userdata)\n"
		"SoMFBool_setValuesPointer(SoMFBool self, int const num, SbBool * userdata)\n"
		""},
	 { "SoMFBool_initClass", _wrap_SoMFBool_initClass, METH_NOARGS, "SoMFBool_initClass()"},
	 { "SoMFBool_setValue", _wrap_SoMFBool_setValue, METH_VARARGS, "\n"
		"SoMFBool_setValue(SoMFBool self, SbBool value)\n"
		"SoMFBool_setValue(SoMFBool self, SoMFBool other)\n"
		""},
	 { "SoMFBool___getitem__", _wrap_SoMFBool___getitem__, METH_VARARGS, "SoMFBool___getitem__(SoMFBool self, int i) -> SbBool const"},
	 { "SoMFBool___setitem__", _wrap_SoMFBool___setitem__, METH_VARARGS, "SoMFBool___setitem__(SoMFBool self, int i, SbBool value)"},
	 { "SoMFBool_getValues", _wrap_SoMFBool_getValues, METH_VARARGS, "SoMFBool_getValues(SoMFBool self, int i=0) -> SbBool const"},
	 { "SoMFBool_swigregister", SoMFBool_swigregister, METH_O, NULL},
	 { "SoMFBool_swiginit", SoMFBool_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFEnum", _wrap_new_SoMFEnum, METH_NOARGS, "new_SoMFEnum() -> SoMFEnum"},
	 { "delete_SoMFEnum", _wrap_delete_SoMFEnum, METH_O, "delete_SoMFEnum(SoMFEnum self)"},
	 { "SoMFEnum_createInstance", _wrap_SoMFEnum_createInstance, METH_NOARGS, "SoMFEnum_createInstance() -> void *"},
	 { "SoMFEnum_getClassTypeId", _wrap_SoMFEnum_getClassTypeId, METH_NOARGS, "SoMFEnum_getClassTypeId() -> SoType"},
	 { "SoMFEnum_getTypeId", _wrap_SoMFEnum_getTypeId, METH_O, "SoMFEnum_getTypeId(SoMFEnum self) -> SoType"},
	 { "SoMFEnum_copyFrom", _wrap_SoMFEnum_copyFrom, METH_VARARGS, "SoMFEnum_copyFrom(SoMFEnum self, SoField field)"},
	 { "SoMFEnum_isSame", _wrap_SoMFEnum_isSame, METH_VARARGS, "SoMFEnum_isSame(SoMFEnum self, SoField field) -> SbBool"},
	 { "SoMFEnum_find", _wrap_SoMFEnum_find, METH_VARARGS, "SoMFEnum_find(SoMFEnum self, int value, SbBool addifnotfound=0) -> int"},
	 { "SoMFEnum_setValues", _wrap_SoMFEnum_setValues, METH_VARARGS, "SoMFEnum_setValues(SoMFEnum self, int const start, int const num, int const * newvals)"},
	 { "SoMFEnum___eq__", _wrap_SoMFEnum___eq__, METH_VARARGS, "SoMFEnum___eq__(SoMFEnum self, SoMFEnum field) -> SbBool"},
	 { "SoMFEnum___ne__", _wrap_SoMFEnum___ne__, METH_VARARGS, "SoMFEnum___ne__(SoMFEnum self, SoMFEnum field) -> SbBool"},
	 { "SoMFEnum_startEditing", _wrap_SoMFEnum_startEditing, METH_O, "SoMFEnum_startEditing(SoMFEnum self) -> int *"},
	 { "SoMFEnum_finishEditing", _wrap_SoMFEnum_finishEditing, METH_O, "SoMFEnum_finishEditing(SoMFEnum self)"},
	 { "SoMFEnum_initClass", _wrap_SoMFEnum_initClass, METH_NOARGS, "SoMFEnum_initClass()"},
	 { "SoMFEnum_set1Value", _wrap_SoMFEnum_set1Value, METH_VARARGS, "\n"
		"SoMFEnum_set1Value(SoMFEnum self, int const idx, int value)\n"
		"SoMFEnum_set1Value(SoMFEnum self, int const idx, SbName name)\n"
		""},
	 { "SoMFEnum_setEnums", _wrap_SoMFEnum_setEnums, METH_VARARGS, "SoMFEnum_setEnums(SoMFEnum self, int const num, int const *const values, SbName names)"},
	 { "SoMFEnum_getNumEnums", _wrap_SoMFEnum_getNumEnums, METH_O, "SoMFEnum_getNumEnums(SoMFEnum self) -> int"},
	 { "SoMFEnum_getEnum", _wrap_SoMFEnum_getEnum, METH_VARARGS, "SoMFEnum_getEnum(SoMFEnum self, int const idx, SbName name) -> int"},
	 { "SoMFEnum___getitem__", _wrap_SoMFEnum___getitem__, METH_VARARGS, "SoMFEnum___getitem__(SoMFEnum self, int i) -> int const"},
	 { "SoMFEnum___setitem__", _wrap_SoMFEnum___setitem__, METH_VARARGS, "SoMFEnum___setitem__(SoMFEnum self, int i, int value)"},
	 { "SoMFEnum_setValue", _wrap_SoMFEnum_setValue, METH_VARARGS, "\n"
		"SoMFEnum_setValue(SoMFEnum self, int value)\n"
		"SoMFEnum_setValue(SoMFEnum self, SbName name)\n"
		"SoMFEnum_setValue(SoMFEnum self, SoMFEnum other)\n"
		""},
	 { "SoMFEnum_getValues", _wrap_SoMFEnum_getValues, METH_VARARGS, "SoMFEnum_getValues(SoMFEnum self, int i=0) -> int const"},
	 { "SoMFEnum_swigregister", SoMFEnum_swigregister, METH_O, NULL},
	 { "SoMFEnum_swiginit", SoMFEnum_swiginit, METH_VARARGS, NULL},
	 { "SoBoolOperation_getClassTypeId", _wrap_SoBoolOperation_getClassTypeId, METH_NOARGS, "SoBoolOperation_getClassTypeId() -> SoType"},
	 { "SoBoolOperation_getTypeId", _wrap_SoBoolOperation_getTypeId, METH_O, "SoBoolOperation_getTypeId(SoBoolOperation self) -> SoType"},
	 { "SoBoolOperation_getFieldData", _wrap_SoBoolOperation_getFieldData, METH_O, "SoBoolOperation_getFieldData(SoBoolOperation self) -> SoFieldData"},
	 { "SoBoolOperation_getOutputData", _wrap_SoBoolOperation_getOutputData, METH_O, "SoBoolOperation_getOutputData(SoBoolOperation self) -> SoEngineOutputData"},
	 { "SoBoolOperation_createInstance", _wrap_SoBoolOperation_createInstance, METH_NOARGS, "SoBoolOperation_createInstance() -> void *"},
	 { "SoBoolOperation_a_set", _wrap_SoBoolOperation_a_set, METH_VARARGS, "SoBoolOperation_a_set(SoBoolOperation self, SoMFBool a)"},
	 { "SoBoolOperation_a_get", _wrap_SoBoolOperation_a_get, METH_O, "SoBoolOperation_a_get(SoBoolOperation self) -> SoMFBool"},
	 { "SoBoolOperation_b_set", _wrap_SoBoolOperation_b_set, METH_VARARGS, "SoBoolOperation_b_set(SoBoolOperation self, SoMFBool b)"},
	 { "SoBoolOperation_b_get", _wrap_SoBoolOperation_b_get, METH_O, "SoBoolOperation_b_get(SoBoolOperation self) -> SoMFBool"},
	 { "SoBoolOperation_operation_set", _wrap_SoBoolOperation_operation_set, METH_VARARGS, "SoBoolOperation_operation_set(SoBoolOperation self, SoMFEnum operation)"},
	 { "SoBoolOperation_operation_get", _wrap_SoBoolOperation_operation_get, METH_O, "SoBoolOperation_operation_get(SoBoolOperation self) -> SoMFEnum"},
	 { "SoBoolOperation_output_set", _wrap_SoBoolOperation_output_set, METH_VARARGS, "SoBoolOperation_output_set(SoBoolOperation self, SoEngineOutput output)"},
	 { "SoBoolOperation_output_get", _wrap_SoBoolOperation_output_get, METH_O, "SoBoolOperation_output_get(SoBoolOperation self) -> SoEngineOutput"},
	 { "SoBoolOperation_inverse_set", _wrap_SoBoolOperation_inverse_set, METH_VARARGS, "SoBoolOperation_inverse_set(SoBoolOperation self, SoEngineOutput inverse)"},
	 { "SoBoolOperation_inverse_get", _wrap_SoBoolOperation_inverse_get, METH_O, "SoBoolOperation_inverse_get(SoBoolOperation self) -> SoEngineOutput"},
	 { "new_SoBoolOperation", _wrap_new_SoBoolOperation, METH_NOARGS, "new_SoBoolOperation() -> SoBoolOperation"},
	 { "SoBoolOperation_initClass", _wrap_SoBoolOperation_initClass, METH_NOARGS, "SoBoolOperation_initClass()"},
	 { "SoBoolOperation_swigregister", SoBoolOperation_swigregister, METH_O, NULL},
	 { "SoBoolOperation_swiginit", SoBoolOperation_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFFloat", _wrap_new_SoMFFloat, METH_NOARGS, "new_SoMFFloat() -> SoMFFloat"},
	 { "delete_SoMFFloat", _wrap_delete_SoMFFloat, METH_O, "delete_SoMFFloat(SoMFFloat self)"},
	 { "SoMFFloat_createInstance", _wrap_SoMFFloat_createInstance, METH_NOARGS, "SoMFFloat_createInstance() -> void *"},
	 { "SoMFFloat_getClassTypeId", _wrap_SoMFFloat_getClassTypeId, METH_NOARGS, "SoMFFloat_getClassTypeId() -> SoType"},
	 { "SoMFFloat_getTypeId", _wrap_SoMFFloat_getTypeId, METH_O, "SoMFFloat_getTypeId(SoMFFloat self) -> SoType"},
	 { "SoMFFloat_copyFrom", _wrap_SoMFFloat_copyFrom, METH_VARARGS, "SoMFFloat_copyFrom(SoMFFloat self, SoField field)"},
	 { "SoMFFloat_isSame", _wrap_SoMFFloat_isSame, METH_VARARGS, "SoMFFloat_isSame(SoMFFloat self, SoField field) -> SbBool"},
	 { "SoMFFloat_find", _wrap_SoMFFloat_find, METH_VARARGS, "SoMFFloat_find(SoMFFloat self, float value, SbBool addifnotfound=0) -> int"},
	 { "SoMFFloat_setValues", _wrap_SoMFFloat_setValues, METH_VARARGS, "SoMFFloat_setValues(SoMFFloat self, int const start, int const num, float const * newvals)"},
	 { "SoMFFloat_set1Value", _wrap_SoMFFloat_set1Value, METH_VARARGS, "SoMFFloat_set1Value(SoMFFloat self, int const idx, float value)"},
	 { "SoMFFloat___eq__", _wrap_SoMFFloat___eq__, METH_VARARGS, "SoMFFloat___eq__(SoMFFloat self, SoMFFloat field) -> SbBool"},
	 { "SoMFFloat___ne__", _wrap_SoMFFloat___ne__, METH_VARARGS, "SoMFFloat___ne__(SoMFFloat self, SoMFFloat field) -> SbBool"},
	 { "SoMFFloat_startEditing", _wrap_SoMFFloat_startEditing, METH_O, "SoMFFloat_startEditing(SoMFFloat self) -> float *"},
	 { "SoMFFloat_finishEditing", _wrap_SoMFFloat_finishEditing, METH_O, "SoMFFloat_finishEditing(SoMFFloat self)"},
	 { "SoMFFloat_setValuesPointer", _wrap_SoMFFloat_setValuesPointer, METH_VARARGS, "\n"
		"SoMFFloat_setValuesPointer(SoMFFloat self, int const num, float const * userdata)\n"
		"SoMFFloat_setValuesPointer(SoMFFloat self, int const num, float * userdata)\n"
		""},
	 { "SoMFFloat_initClass", _wrap_SoMFFloat_initClass, METH_NOARGS, "SoMFFloat_initClass()"},
	 { "SoMFFloat___getitem__", _wrap_SoMFFloat___getitem__, METH_VARARGS, "SoMFFloat___getitem__(SoMFFloat self, int i) -> float const"},
	 { "SoMFFloat___setitem__", _wrap_SoMFFloat___setitem__, METH_VARARGS, "SoMFFloat___setitem__(SoMFFloat self, int i, float value)"},
	 { "SoMFFloat_setValue", _wrap_SoMFFloat_setValue, METH_VARARGS, "\n"
		"SoMFFloat_setValue(SoMFFloat self, float value)\n"
		"SoMFFloat_setValue(SoMFFloat self, SoMFFloat other)\n"
		""},
	 { "SoMFFloat_getValues", _wrap_SoMFFloat_getValues, METH_VARARGS, "SoMFFloat_getValues(SoMFFloat self, int i=0) -> float const"},
	 { "SoMFFloat_swigregister", SoMFFloat_swigregister, METH_O, NULL},
	 { "SoMFFloat_swiginit", SoMFFloat_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec3f", _wrap_new_SoMFVec3f, METH_NOARGS, "new_SoMFVec3f() -> SoMFVec3f"},
	 { "delete_SoMFVec3f", _wrap_delete_SoMFVec3f, METH_O, "delete_SoMFVec3f(SoMFVec3f self)"},
	 { "SoMFVec3f_createInstance", _wrap_SoMFVec3f_createInstance, METH_NOARGS, "SoMFVec3f_createInstance() -> void *"},
	 { "SoMFVec3f_getClassTypeId", _wrap_SoMFVec3f_getClassTypeId, METH_NOARGS, "SoMFVec3f_getClassTypeId() -> SoType"},
	 { "SoMFVec3f_getTypeId", _wrap_SoMFVec3f_getTypeId, METH_O, "SoMFVec3f_getTypeId(SoMFVec3f self) -> SoType"},
	 { "SoMFVec3f_copyFrom", _wrap_SoMFVec3f_copyFrom, METH_VARARGS, "SoMFVec3f_copyFrom(SoMFVec3f self, SoField field)"},
	 { "SoMFVec3f_isSame", _wrap_SoMFVec3f_isSame, METH_VARARGS, "SoMFVec3f_isSame(SoMFVec3f self, SoField field) -> SbBool"},
	 { "SoMFVec3f_find", _wrap_SoMFVec3f_find, METH_VARARGS, "SoMFVec3f_find(SoMFVec3f self, SbVec3f value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec3f___eq__", _wrap_SoMFVec3f___eq__, METH_VARARGS, "SoMFVec3f___eq__(SoMFVec3f self, SoMFVec3f field) -> SbBool"},
	 { "SoMFVec3f___ne__", _wrap_SoMFVec3f___ne__, METH_VARARGS, "SoMFVec3f___ne__(SoMFVec3f self, SoMFVec3f field) -> SbBool"},
	 { "SoMFVec3f_startEditing", _wrap_SoMFVec3f_startEditing, METH_O, "SoMFVec3f_startEditing(SoMFVec3f self) -> SbVec3f"},
	 { "SoMFVec3f_finishEditing", _wrap_SoMFVec3f_finishEditing, METH_O, "SoMFVec3f_finishEditing(SoMFVec3f self)"},
	 { "SoMFVec3f_setValuesPointer", _wrap_SoMFVec3f_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec3f_setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)\n"
		"SoMFVec3f_setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)\n"
		"SoMFVec3f_setValuesPointer(SoMFVec3f self, int const num, float const * userdata)\n"
		"SoMFVec3f_setValuesPointer(SoMFVec3f self, int const num, float * userdata)\n"
		""},
	 { "SoMFVec3f_initClass", _wrap_SoMFVec3f_initClass, METH_NOARGS, "SoMFVec3f_initClass()"},
	 { "SoMFVec3f_setValues", _wrap_SoMFVec3f_setValues, METH_VARARGS, "\n"
		"SoMFVec3f_setValues(SoMFVec3f self, int const start, int const num, SbVec3f newvals)\n"
		"SoMFVec3f_setValues(SoMFVec3f self, int start, int num, float const [][3] xyz)\n"
		""},
	 { "SoMFVec3f_set1Value", _wrap_SoMFVec3f_set1Value, METH_VARARGS, "\n"
		"SoMFVec3f_set1Value(SoMFVec3f self, int const idx, SbVec3f value)\n"
		"SoMFVec3f_set1Value(SoMFVec3f self, int idx, float x, float y, float z)\n"
		"SoMFVec3f_set1Value(SoMFVec3f self, int idx, float const [3] xyz)\n"
		""},
	 { "SoMFVec3f___getitem__", _wrap_SoMFVec3f___getitem__, METH_VARARGS, "SoMFVec3f___getitem__(SoMFVec3f self, int i) -> SbVec3f"},
	 { "SoMFVec3f___setitem__", _wrap_SoMFVec3f___setitem__, METH_VARARGS, "SoMFVec3f___setitem__(SoMFVec3f self, int i, SbVec3f value)"},
	 { "SoMFVec3f_setValue", _wrap_SoMFVec3f_setValue, METH_VARARGS, "\n"
		"SoMFVec3f_setValue(SoMFVec3f self, SbVec3f value)\n"
		"SoMFVec3f_setValue(SoMFVec3f self, float x, float y, float z)\n"
		"SoMFVec3f_setValue(SoMFVec3f self, float const [3] xyz)\n"
		"SoMFVec3f_setValue(SoMFVec3f self, SoMFVec3f other)\n"
		""},
	 { "SoMFVec3f_getValues", _wrap_SoMFVec3f_getValues, METH_VARARGS, "SoMFVec3f_getValues(SoMFVec3f self, int i=0) -> SbVec3f"},
	 { "SoMFVec3f_swigregister", SoMFVec3f_swigregister, METH_O, NULL},
	 { "SoMFVec3f_swiginit", SoMFVec3f_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFString", _wrap_new_SoMFString, METH_NOARGS, "new_SoMFString() -> SoMFString"},
	 { "delete_SoMFString", _wrap_delete_SoMFString, METH_O, "delete_SoMFString(SoMFString self)"},
	 { "SoMFString_createInstance", _wrap_SoMFString_createInstance, METH_NOARGS, "SoMFString_createInstance() -> void *"},
	 { "SoMFString_getClassTypeId", _wrap_SoMFString_getClassTypeId, METH_NOARGS, "SoMFString_getClassTypeId() -> SoType"},
	 { "SoMFString_getTypeId", _wrap_SoMFString_getTypeId, METH_O, "SoMFString_getTypeId(SoMFString self) -> SoType"},
	 { "SoMFString_copyFrom", _wrap_SoMFString_copyFrom, METH_VARARGS, "SoMFString_copyFrom(SoMFString self, SoField field)"},
	 { "SoMFString_isSame", _wrap_SoMFString_isSame, METH_VARARGS, "SoMFString_isSame(SoMFString self, SoField field) -> SbBool"},
	 { "SoMFString_find", _wrap_SoMFString_find, METH_VARARGS, "SoMFString_find(SoMFString self, SbString value, SbBool addifnotfound=0) -> int"},
	 { "SoMFString_set1Value", _wrap_SoMFString_set1Value, METH_VARARGS, "SoMFString_set1Value(SoMFString self, int const idx, SbString value)"},
	 { "SoMFString___eq__", _wrap_SoMFString___eq__, METH_VARARGS, "SoMFString___eq__(SoMFString self, SoMFString field) -> SbBool"},
	 { "SoMFString___ne__", _wrap_SoMFString___ne__, METH_VARARGS, "SoMFString___ne__(SoMFString self, SoMFString field) -> SbBool"},
	 { "SoMFString_startEditing", _wrap_SoMFString_startEditing, METH_O, "SoMFString_startEditing(SoMFString self) -> SbString"},
	 { "SoMFString_finishEditing", _wrap_SoMFString_finishEditing, METH_O, "SoMFString_finishEditing(SoMFString self)"},
	 { "SoMFString_initClass", _wrap_SoMFString_initClass, METH_NOARGS, "SoMFString_initClass()"},
	 { "SoMFString_setValues", _wrap_SoMFString_setValues, METH_VARARGS, "\n"
		"SoMFString_setValues(SoMFString self, int const start, int const num, SbString newvals)\n"
		"SoMFString_setValues(SoMFString self, int const start, int const num, char const *[] strings)\n"
		""},
	 { "SoMFString_deleteText", _wrap_SoMFString_deleteText, METH_VARARGS, "SoMFString_deleteText(SoMFString self, int const fromline, int const fromchar, int const toline, int const tochar)"},
	 { "SoMFString___getitem__", _wrap_SoMFString___getitem__, METH_VARARGS, "SoMFString___getitem__(SoMFString self, int i) -> SbString"},
	 { "SoMFString___setitem__", _wrap_SoMFString___setitem__, METH_VARARGS, "SoMFString___setitem__(SoMFString self, int i, SbString value)"},
	 { "SoMFString_setValue", _wrap_SoMFString_setValue, METH_VARARGS, "\n"
		"SoMFString_setValue(SoMFString self, SbString value)\n"
		"SoMFString_setValue(SoMFString self, char const * string)\n"
		"SoMFString_setValue(SoMFString self, SoMFString other)\n"
		""},
	 { "SoMFString_getValues", _wrap_SoMFString_getValues, METH_VARARGS, "SoMFString_getValues(SoMFString self, int i=0) -> SbString"},
	 { "SoMFString_swigregister", SoMFString_swigregister, METH_O, NULL},
	 { "SoMFString_swiginit", SoMFString_swiginit, METH_VARARGS, NULL},
	 { "SoCalculator_getClassTypeId", _wrap_SoCalculator_getClassTypeId, METH_NOARGS, "SoCalculator_getClassTypeId() -> SoType"},
	 { "SoCalculator_getTypeId", _wrap_SoCalculator_getTypeId, METH_O, "SoCalculator_getTypeId(SoCalculator self) -> SoType"},
	 { "SoCalculator_getFieldData", _wrap_SoCalculator_getFieldData, METH_O, "SoCalculator_getFieldData(SoCalculator self) -> SoFieldData"},
	 { "SoCalculator_getOutputData", _wrap_SoCalculator_getOutputData, METH_O, "SoCalculator_getOutputData(SoCalculator self) -> SoEngineOutputData"},
	 { "SoCalculator_createInstance", _wrap_SoCalculator_createInstance, METH_NOARGS, "SoCalculator_createInstance() -> void *"},
	 { "SoCalculator_a_set", _wrap_SoCalculator_a_set, METH_VARARGS, "SoCalculator_a_set(SoCalculator self, SoMFFloat a)"},
	 { "SoCalculator_a_get", _wrap_SoCalculator_a_get, METH_O, "SoCalculator_a_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_b_set", _wrap_SoCalculator_b_set, METH_VARARGS, "SoCalculator_b_set(SoCalculator self, SoMFFloat b)"},
	 { "SoCalculator_b_get", _wrap_SoCalculator_b_get, METH_O, "SoCalculator_b_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_c_set", _wrap_SoCalculator_c_set, METH_VARARGS, "SoCalculator_c_set(SoCalculator self, SoMFFloat c)"},
	 { "SoCalculator_c_get", _wrap_SoCalculator_c_get, METH_O, "SoCalculator_c_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_d_set", _wrap_SoCalculator_d_set, METH_VARARGS, "SoCalculator_d_set(SoCalculator self, SoMFFloat d)"},
	 { "SoCalculator_d_get", _wrap_SoCalculator_d_get, METH_O, "SoCalculator_d_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_e_set", _wrap_SoCalculator_e_set, METH_VARARGS, "SoCalculator_e_set(SoCalculator self, SoMFFloat e)"},
	 { "SoCalculator_e_get", _wrap_SoCalculator_e_get, METH_O, "SoCalculator_e_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_f_set", _wrap_SoCalculator_f_set, METH_VARARGS, "SoCalculator_f_set(SoCalculator self, SoMFFloat f)"},
	 { "SoCalculator_f_get", _wrap_SoCalculator_f_get, METH_O, "SoCalculator_f_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_g_set", _wrap_SoCalculator_g_set, METH_VARARGS, "SoCalculator_g_set(SoCalculator self, SoMFFloat g)"},
	 { "SoCalculator_g_get", _wrap_SoCalculator_g_get, METH_O, "SoCalculator_g_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_h_set", _wrap_SoCalculator_h_set, METH_VARARGS, "SoCalculator_h_set(SoCalculator self, SoMFFloat h)"},
	 { "SoCalculator_h_get", _wrap_SoCalculator_h_get, METH_O, "SoCalculator_h_get(SoCalculator self) -> SoMFFloat"},
	 { "SoCalculator_A_set", _wrap_SoCalculator_A_set, METH_VARARGS, "SoCalculator_A_set(SoCalculator self, SoMFVec3f A)"},
	 { "SoCalculator_A_get", _wrap_SoCalculator_A_get, METH_O, "SoCalculator_A_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_B_set", _wrap_SoCalculator_B_set, METH_VARARGS, "SoCalculator_B_set(SoCalculator self, SoMFVec3f B)"},
	 { "SoCalculator_B_get", _wrap_SoCalculator_B_get, METH_O, "SoCalculator_B_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_C_set", _wrap_SoCalculator_C_set, METH_VARARGS, "SoCalculator_C_set(SoCalculator self, SoMFVec3f C)"},
	 { "SoCalculator_C_get", _wrap_SoCalculator_C_get, METH_O, "SoCalculator_C_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_D_set", _wrap_SoCalculator_D_set, METH_VARARGS, "SoCalculator_D_set(SoCalculator self, SoMFVec3f D)"},
	 { "SoCalculator_D_get", _wrap_SoCalculator_D_get, METH_O, "SoCalculator_D_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_E_set", _wrap_SoCalculator_E_set, METH_VARARGS, "SoCalculator_E_set(SoCalculator self, SoMFVec3f E)"},
	 { "SoCalculator_E_get", _wrap_SoCalculator_E_get, METH_O, "SoCalculator_E_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_F_set", _wrap_SoCalculator_F_set, METH_VARARGS, "SoCalculator_F_set(SoCalculator self, SoMFVec3f F)"},
	 { "SoCalculator_F_get", _wrap_SoCalculator_F_get, METH_O, "SoCalculator_F_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_G_set", _wrap_SoCalculator_G_set, METH_VARARGS, "SoCalculator_G_set(SoCalculator self, SoMFVec3f G)"},
	 { "SoCalculator_G_get", _wrap_SoCalculator_G_get, METH_O, "SoCalculator_G_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_H_set", _wrap_SoCalculator_H_set, METH_VARARGS, "SoCalculator_H_set(SoCalculator self, SoMFVec3f H)"},
	 { "SoCalculator_H_get", _wrap_SoCalculator_H_get, METH_O, "SoCalculator_H_get(SoCalculator self) -> SoMFVec3f"},
	 { "SoCalculator_expression_set", _wrap_SoCalculator_expression_set, METH_VARARGS, "SoCalculator_expression_set(SoCalculator self, SoMFString expression)"},
	 { "SoCalculator_expression_get", _wrap_SoCalculator_expression_get, METH_O, "SoCalculator_expression_get(SoCalculator self) -> SoMFString"},
	 { "SoCalculator_oa_set", _wrap_SoCalculator_oa_set, METH_VARARGS, "SoCalculator_oa_set(SoCalculator self, SoEngineOutput oa)"},
	 { "SoCalculator_oa_get", _wrap_SoCalculator_oa_get, METH_O, "SoCalculator_oa_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_ob_set", _wrap_SoCalculator_ob_set, METH_VARARGS, "SoCalculator_ob_set(SoCalculator self, SoEngineOutput ob)"},
	 { "SoCalculator_ob_get", _wrap_SoCalculator_ob_get, METH_O, "SoCalculator_ob_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_oc_set", _wrap_SoCalculator_oc_set, METH_VARARGS, "SoCalculator_oc_set(SoCalculator self, SoEngineOutput oc)"},
	 { "SoCalculator_oc_get", _wrap_SoCalculator_oc_get, METH_O, "SoCalculator_oc_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_od_set", _wrap_SoCalculator_od_set, METH_VARARGS, "SoCalculator_od_set(SoCalculator self, SoEngineOutput od)"},
	 { "SoCalculator_od_get", _wrap_SoCalculator_od_get, METH_O, "SoCalculator_od_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_oA_set", _wrap_SoCalculator_oA_set, METH_VARARGS, "SoCalculator_oA_set(SoCalculator self, SoEngineOutput oA)"},
	 { "SoCalculator_oA_get", _wrap_SoCalculator_oA_get, METH_O, "SoCalculator_oA_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_oB_set", _wrap_SoCalculator_oB_set, METH_VARARGS, "SoCalculator_oB_set(SoCalculator self, SoEngineOutput oB)"},
	 { "SoCalculator_oB_get", _wrap_SoCalculator_oB_get, METH_O, "SoCalculator_oB_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_oC_set", _wrap_SoCalculator_oC_set, METH_VARARGS, "SoCalculator_oC_set(SoCalculator self, SoEngineOutput oC)"},
	 { "SoCalculator_oC_get", _wrap_SoCalculator_oC_get, METH_O, "SoCalculator_oC_get(SoCalculator self) -> SoEngineOutput"},
	 { "SoCalculator_oD_set", _wrap_SoCalculator_oD_set, METH_VARARGS, "SoCalculator_oD_set(SoCalculator self, SoEngineOutput oD)"},
	 { "SoCalculator_oD_get", _wrap_SoCalculator_oD_get, METH_O, "SoCalculator_oD_get(SoCalculator self) -> SoEngineOutput"},
	 { "new_SoCalculator", _wrap_new_SoCalculator, METH_NOARGS, "new_SoCalculator() -> SoCalculator"},
	 { "SoCalculator_initClass", _wrap_SoCalculator_initClass, METH_NOARGS, "SoCalculator_initClass()"},
	 { "SoCalculator_swigregister", SoCalculator_swigregister, METH_O, NULL},
	 { "SoCalculator_swiginit", SoCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec2f", _wrap_new_SoMFVec2f, METH_NOARGS, "new_SoMFVec2f() -> SoMFVec2f"},
	 { "delete_SoMFVec2f", _wrap_delete_SoMFVec2f, METH_O, "delete_SoMFVec2f(SoMFVec2f self)"},
	 { "SoMFVec2f_createInstance", _wrap_SoMFVec2f_createInstance, METH_NOARGS, "SoMFVec2f_createInstance() -> void *"},
	 { "SoMFVec2f_getClassTypeId", _wrap_SoMFVec2f_getClassTypeId, METH_NOARGS, "SoMFVec2f_getClassTypeId() -> SoType"},
	 { "SoMFVec2f_getTypeId", _wrap_SoMFVec2f_getTypeId, METH_O, "SoMFVec2f_getTypeId(SoMFVec2f self) -> SoType"},
	 { "SoMFVec2f_copyFrom", _wrap_SoMFVec2f_copyFrom, METH_VARARGS, "SoMFVec2f_copyFrom(SoMFVec2f self, SoField field)"},
	 { "SoMFVec2f_isSame", _wrap_SoMFVec2f_isSame, METH_VARARGS, "SoMFVec2f_isSame(SoMFVec2f self, SoField field) -> SbBool"},
	 { "SoMFVec2f_find", _wrap_SoMFVec2f_find, METH_VARARGS, "SoMFVec2f_find(SoMFVec2f self, SbVec2f value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec2f___eq__", _wrap_SoMFVec2f___eq__, METH_VARARGS, "SoMFVec2f___eq__(SoMFVec2f self, SoMFVec2f field) -> SbBool"},
	 { "SoMFVec2f___ne__", _wrap_SoMFVec2f___ne__, METH_VARARGS, "SoMFVec2f___ne__(SoMFVec2f self, SoMFVec2f field) -> SbBool"},
	 { "SoMFVec2f_startEditing", _wrap_SoMFVec2f_startEditing, METH_O, "SoMFVec2f_startEditing(SoMFVec2f self) -> SbVec2f"},
	 { "SoMFVec2f_finishEditing", _wrap_SoMFVec2f_finishEditing, METH_O, "SoMFVec2f_finishEditing(SoMFVec2f self)"},
	 { "SoMFVec2f_setValuesPointer", _wrap_SoMFVec2f_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec2f_setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)\n"
		"SoMFVec2f_setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)\n"
		"SoMFVec2f_setValuesPointer(SoMFVec2f self, int const num, float const * userdata)\n"
		"SoMFVec2f_setValuesPointer(SoMFVec2f self, int const num, float * userdata)\n"
		""},
	 { "SoMFVec2f_initClass", _wrap_SoMFVec2f_initClass, METH_NOARGS, "SoMFVec2f_initClass()"},
	 { "SoMFVec2f_setValues", _wrap_SoMFVec2f_setValues, METH_VARARGS, "\n"
		"SoMFVec2f_setValues(SoMFVec2f self, int const start, int const num, SbVec2f newvals)\n"
		"SoMFVec2f_setValues(SoMFVec2f self, int start, int num, float const [][2] xy)\n"
		""},
	 { "SoMFVec2f_set1Value", _wrap_SoMFVec2f_set1Value, METH_VARARGS, "\n"
		"SoMFVec2f_set1Value(SoMFVec2f self, int const idx, SbVec2f value)\n"
		"SoMFVec2f_set1Value(SoMFVec2f self, int idx, float x, float y)\n"
		"SoMFVec2f_set1Value(SoMFVec2f self, int idx, float const [2] xy)\n"
		""},
	 { "SoMFVec2f___getitem__", _wrap_SoMFVec2f___getitem__, METH_VARARGS, "SoMFVec2f___getitem__(SoMFVec2f self, int i) -> SbVec2f"},
	 { "SoMFVec2f___setitem__", _wrap_SoMFVec2f___setitem__, METH_VARARGS, "SoMFVec2f___setitem__(SoMFVec2f self, int i, SbVec2f value)"},
	 { "SoMFVec2f_setValue", _wrap_SoMFVec2f_setValue, METH_VARARGS, "\n"
		"SoMFVec2f_setValue(SoMFVec2f self, SbVec2f value)\n"
		"SoMFVec2f_setValue(SoMFVec2f self, float x, float y)\n"
		"SoMFVec2f_setValue(SoMFVec2f self, float const [2] xy)\n"
		"SoMFVec2f_setValue(SoMFVec2f self, SoMFVec2f other)\n"
		""},
	 { "SoMFVec2f_getValues", _wrap_SoMFVec2f_getValues, METH_VARARGS, "SoMFVec2f_getValues(SoMFVec2f self, int i=0) -> SbVec2f"},
	 { "SoMFVec2f_swigregister", SoMFVec2f_swigregister, METH_O, NULL},
	 { "SoMFVec2f_swiginit", SoMFVec2f_swiginit, METH_VARARGS, NULL},
	 { "SoComposeVec2f_getClassTypeId", _wrap_SoComposeVec2f_getClassTypeId, METH_NOARGS, "SoComposeVec2f_getClassTypeId() -> SoType"},
	 { "SoComposeVec2f_getTypeId", _wrap_SoComposeVec2f_getTypeId, METH_O, "SoComposeVec2f_getTypeId(SoComposeVec2f self) -> SoType"},
	 { "SoComposeVec2f_getFieldData", _wrap_SoComposeVec2f_getFieldData, METH_O, "SoComposeVec2f_getFieldData(SoComposeVec2f self) -> SoFieldData"},
	 { "SoComposeVec2f_getOutputData", _wrap_SoComposeVec2f_getOutputData, METH_O, "SoComposeVec2f_getOutputData(SoComposeVec2f self) -> SoEngineOutputData"},
	 { "SoComposeVec2f_createInstance", _wrap_SoComposeVec2f_createInstance, METH_NOARGS, "SoComposeVec2f_createInstance() -> void *"},
	 { "new_SoComposeVec2f", _wrap_new_SoComposeVec2f, METH_NOARGS, "new_SoComposeVec2f() -> SoComposeVec2f"},
	 { "SoComposeVec2f_initClass", _wrap_SoComposeVec2f_initClass, METH_NOARGS, "SoComposeVec2f_initClass()"},
	 { "SoComposeVec2f_x_set", _wrap_SoComposeVec2f_x_set, METH_VARARGS, "SoComposeVec2f_x_set(SoComposeVec2f self, SoMFFloat x)"},
	 { "SoComposeVec2f_x_get", _wrap_SoComposeVec2f_x_get, METH_O, "SoComposeVec2f_x_get(SoComposeVec2f self) -> SoMFFloat"},
	 { "SoComposeVec2f_y_set", _wrap_SoComposeVec2f_y_set, METH_VARARGS, "SoComposeVec2f_y_set(SoComposeVec2f self, SoMFFloat y)"},
	 { "SoComposeVec2f_y_get", _wrap_SoComposeVec2f_y_get, METH_O, "SoComposeVec2f_y_get(SoComposeVec2f self) -> SoMFFloat"},
	 { "SoComposeVec2f_vector_set", _wrap_SoComposeVec2f_vector_set, METH_VARARGS, "SoComposeVec2f_vector_set(SoComposeVec2f self, SoEngineOutput vector)"},
	 { "SoComposeVec2f_vector_get", _wrap_SoComposeVec2f_vector_get, METH_O, "SoComposeVec2f_vector_get(SoComposeVec2f self) -> SoEngineOutput"},
	 { "SoComposeVec2f_swigregister", SoComposeVec2f_swigregister, METH_O, NULL},
	 { "SoComposeVec2f_swiginit", SoComposeVec2f_swiginit, METH_VARARGS, NULL},
	 { "SoComposeVec3f_getClassTypeId", _wrap_SoComposeVec3f_getClassTypeId, METH_NOARGS, "SoComposeVec3f_getClassTypeId() -> SoType"},
	 { "SoComposeVec3f_getTypeId", _wrap_SoComposeVec3f_getTypeId, METH_O, "SoComposeVec3f_getTypeId(SoComposeVec3f self) -> SoType"},
	 { "SoComposeVec3f_getFieldData", _wrap_SoComposeVec3f_getFieldData, METH_O, "SoComposeVec3f_getFieldData(SoComposeVec3f self) -> SoFieldData"},
	 { "SoComposeVec3f_getOutputData", _wrap_SoComposeVec3f_getOutputData, METH_O, "SoComposeVec3f_getOutputData(SoComposeVec3f self) -> SoEngineOutputData"},
	 { "SoComposeVec3f_createInstance", _wrap_SoComposeVec3f_createInstance, METH_NOARGS, "SoComposeVec3f_createInstance() -> void *"},
	 { "new_SoComposeVec3f", _wrap_new_SoComposeVec3f, METH_NOARGS, "new_SoComposeVec3f() -> SoComposeVec3f"},
	 { "SoComposeVec3f_initClass", _wrap_SoComposeVec3f_initClass, METH_NOARGS, "SoComposeVec3f_initClass()"},
	 { "SoComposeVec3f_x_set", _wrap_SoComposeVec3f_x_set, METH_VARARGS, "SoComposeVec3f_x_set(SoComposeVec3f self, SoMFFloat x)"},
	 { "SoComposeVec3f_x_get", _wrap_SoComposeVec3f_x_get, METH_O, "SoComposeVec3f_x_get(SoComposeVec3f self) -> SoMFFloat"},
	 { "SoComposeVec3f_y_set", _wrap_SoComposeVec3f_y_set, METH_VARARGS, "SoComposeVec3f_y_set(SoComposeVec3f self, SoMFFloat y)"},
	 { "SoComposeVec3f_y_get", _wrap_SoComposeVec3f_y_get, METH_O, "SoComposeVec3f_y_get(SoComposeVec3f self) -> SoMFFloat"},
	 { "SoComposeVec3f_z_set", _wrap_SoComposeVec3f_z_set, METH_VARARGS, "SoComposeVec3f_z_set(SoComposeVec3f self, SoMFFloat z)"},
	 { "SoComposeVec3f_z_get", _wrap_SoComposeVec3f_z_get, METH_O, "SoComposeVec3f_z_get(SoComposeVec3f self) -> SoMFFloat"},
	 { "SoComposeVec3f_vector_set", _wrap_SoComposeVec3f_vector_set, METH_VARARGS, "SoComposeVec3f_vector_set(SoComposeVec3f self, SoEngineOutput vector)"},
	 { "SoComposeVec3f_vector_get", _wrap_SoComposeVec3f_vector_get, METH_O, "SoComposeVec3f_vector_get(SoComposeVec3f self) -> SoEngineOutput"},
	 { "SoComposeVec3f_swigregister", SoComposeVec3f_swigregister, METH_O, NULL},
	 { "SoComposeVec3f_swiginit", SoComposeVec3f_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4f", _wrap_new_SoMFVec4f, METH_NOARGS, "new_SoMFVec4f() -> SoMFVec4f"},
	 { "delete_SoMFVec4f", _wrap_delete_SoMFVec4f, METH_O, "delete_SoMFVec4f(SoMFVec4f self)"},
	 { "SoMFVec4f_createInstance", _wrap_SoMFVec4f_createInstance, METH_NOARGS, "SoMFVec4f_createInstance() -> void *"},
	 { "SoMFVec4f_getClassTypeId", _wrap_SoMFVec4f_getClassTypeId, METH_NOARGS, "SoMFVec4f_getClassTypeId() -> SoType"},
	 { "SoMFVec4f_getTypeId", _wrap_SoMFVec4f_getTypeId, METH_O, "SoMFVec4f_getTypeId(SoMFVec4f self) -> SoType"},
	 { "SoMFVec4f_copyFrom", _wrap_SoMFVec4f_copyFrom, METH_VARARGS, "SoMFVec4f_copyFrom(SoMFVec4f self, SoField field)"},
	 { "SoMFVec4f_isSame", _wrap_SoMFVec4f_isSame, METH_VARARGS, "SoMFVec4f_isSame(SoMFVec4f self, SoField field) -> SbBool"},
	 { "SoMFVec4f_find", _wrap_SoMFVec4f_find, METH_VARARGS, "SoMFVec4f_find(SoMFVec4f self, SbVec4f value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4f___eq__", _wrap_SoMFVec4f___eq__, METH_VARARGS, "SoMFVec4f___eq__(SoMFVec4f self, SoMFVec4f field) -> SbBool"},
	 { "SoMFVec4f___ne__", _wrap_SoMFVec4f___ne__, METH_VARARGS, "SoMFVec4f___ne__(SoMFVec4f self, SoMFVec4f field) -> SbBool"},
	 { "SoMFVec4f_startEditing", _wrap_SoMFVec4f_startEditing, METH_O, "SoMFVec4f_startEditing(SoMFVec4f self) -> SbVec4f"},
	 { "SoMFVec4f_finishEditing", _wrap_SoMFVec4f_finishEditing, METH_O, "SoMFVec4f_finishEditing(SoMFVec4f self)"},
	 { "SoMFVec4f_setValuesPointer", _wrap_SoMFVec4f_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4f_setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)\n"
		"SoMFVec4f_setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)\n"
		"SoMFVec4f_setValuesPointer(SoMFVec4f self, int const num, float const * userdata)\n"
		"SoMFVec4f_setValuesPointer(SoMFVec4f self, int const num, float * userdata)\n"
		""},
	 { "SoMFVec4f_initClass", _wrap_SoMFVec4f_initClass, METH_NOARGS, "SoMFVec4f_initClass()"},
	 { "SoMFVec4f_setValues", _wrap_SoMFVec4f_setValues, METH_VARARGS, "\n"
		"SoMFVec4f_setValues(SoMFVec4f self, int const start, int const num, SbVec4f newvals)\n"
		"SoMFVec4f_setValues(SoMFVec4f self, int start, int num, float const [][4] xyzw)\n"
		""},
	 { "SoMFVec4f_set1Value", _wrap_SoMFVec4f_set1Value, METH_VARARGS, "\n"
		"SoMFVec4f_set1Value(SoMFVec4f self, int const idx, SbVec4f value)\n"
		"SoMFVec4f_set1Value(SoMFVec4f self, int idx, float x, float y, float z, float w)\n"
		"SoMFVec4f_set1Value(SoMFVec4f self, int idx, float const [4] xyzw)\n"
		""},
	 { "SoMFVec4f___getitem__", _wrap_SoMFVec4f___getitem__, METH_VARARGS, "SoMFVec4f___getitem__(SoMFVec4f self, int i) -> SbVec4f"},
	 { "SoMFVec4f___setitem__", _wrap_SoMFVec4f___setitem__, METH_VARARGS, "SoMFVec4f___setitem__(SoMFVec4f self, int i, SbVec4f value)"},
	 { "SoMFVec4f_setValue", _wrap_SoMFVec4f_setValue, METH_VARARGS, "\n"
		"SoMFVec4f_setValue(SoMFVec4f self, SbVec4f value)\n"
		"SoMFVec4f_setValue(SoMFVec4f self, float x, float y, float z, float w)\n"
		"SoMFVec4f_setValue(SoMFVec4f self, float const [4] xyzw)\n"
		"SoMFVec4f_setValue(SoMFVec4f self, SoMFVec4f other)\n"
		""},
	 { "SoMFVec4f_getValues", _wrap_SoMFVec4f_getValues, METH_VARARGS, "SoMFVec4f_getValues(SoMFVec4f self, int i=0) -> SbVec4f"},
	 { "SoMFVec4f_swigregister", SoMFVec4f_swigregister, METH_O, NULL},
	 { "SoMFVec4f_swiginit", SoMFVec4f_swiginit, METH_VARARGS, NULL},
	 { "SoComposeVec4f_getClassTypeId", _wrap_SoComposeVec4f_getClassTypeId, METH_NOARGS, "SoComposeVec4f_getClassTypeId() -> SoType"},
	 { "SoComposeVec4f_getTypeId", _wrap_SoComposeVec4f_getTypeId, METH_O, "SoComposeVec4f_getTypeId(SoComposeVec4f self) -> SoType"},
	 { "SoComposeVec4f_getFieldData", _wrap_SoComposeVec4f_getFieldData, METH_O, "SoComposeVec4f_getFieldData(SoComposeVec4f self) -> SoFieldData"},
	 { "SoComposeVec4f_getOutputData", _wrap_SoComposeVec4f_getOutputData, METH_O, "SoComposeVec4f_getOutputData(SoComposeVec4f self) -> SoEngineOutputData"},
	 { "SoComposeVec4f_createInstance", _wrap_SoComposeVec4f_createInstance, METH_NOARGS, "SoComposeVec4f_createInstance() -> void *"},
	 { "new_SoComposeVec4f", _wrap_new_SoComposeVec4f, METH_NOARGS, "new_SoComposeVec4f() -> SoComposeVec4f"},
	 { "SoComposeVec4f_initClass", _wrap_SoComposeVec4f_initClass, METH_NOARGS, "SoComposeVec4f_initClass()"},
	 { "SoComposeVec4f_x_set", _wrap_SoComposeVec4f_x_set, METH_VARARGS, "SoComposeVec4f_x_set(SoComposeVec4f self, SoMFFloat x)"},
	 { "SoComposeVec4f_x_get", _wrap_SoComposeVec4f_x_get, METH_O, "SoComposeVec4f_x_get(SoComposeVec4f self) -> SoMFFloat"},
	 { "SoComposeVec4f_y_set", _wrap_SoComposeVec4f_y_set, METH_VARARGS, "SoComposeVec4f_y_set(SoComposeVec4f self, SoMFFloat y)"},
	 { "SoComposeVec4f_y_get", _wrap_SoComposeVec4f_y_get, METH_O, "SoComposeVec4f_y_get(SoComposeVec4f self) -> SoMFFloat"},
	 { "SoComposeVec4f_z_set", _wrap_SoComposeVec4f_z_set, METH_VARARGS, "SoComposeVec4f_z_set(SoComposeVec4f self, SoMFFloat z)"},
	 { "SoComposeVec4f_z_get", _wrap_SoComposeVec4f_z_get, METH_O, "SoComposeVec4f_z_get(SoComposeVec4f self) -> SoMFFloat"},
	 { "SoComposeVec4f_w_set", _wrap_SoComposeVec4f_w_set, METH_VARARGS, "SoComposeVec4f_w_set(SoComposeVec4f self, SoMFFloat w)"},
	 { "SoComposeVec4f_w_get", _wrap_SoComposeVec4f_w_get, METH_O, "SoComposeVec4f_w_get(SoComposeVec4f self) -> SoMFFloat"},
	 { "SoComposeVec4f_vector_set", _wrap_SoComposeVec4f_vector_set, METH_VARARGS, "SoComposeVec4f_vector_set(SoComposeVec4f self, SoEngineOutput vector)"},
	 { "SoComposeVec4f_vector_get", _wrap_SoComposeVec4f_vector_get, METH_O, "SoComposeVec4f_vector_get(SoComposeVec4f self) -> SoEngineOutput"},
	 { "SoComposeVec4f_swigregister", SoComposeVec4f_swigregister, METH_O, NULL},
	 { "SoComposeVec4f_swiginit", SoComposeVec4f_swiginit, METH_VARARGS, NULL},
	 { "SoDecomposeVec2f_getClassTypeId", _wrap_SoDecomposeVec2f_getClassTypeId, METH_NOARGS, "SoDecomposeVec2f_getClassTypeId() -> SoType"},
	 { "SoDecomposeVec2f_getTypeId", _wrap_SoDecomposeVec2f_getTypeId, METH_O, "SoDecomposeVec2f_getTypeId(SoDecomposeVec2f self) -> SoType"},
	 { "SoDecomposeVec2f_getFieldData", _wrap_SoDecomposeVec2f_getFieldData, METH_O, "SoDecomposeVec2f_getFieldData(SoDecomposeVec2f self) -> SoFieldData"},
	 { "SoDecomposeVec2f_getOutputData", _wrap_SoDecomposeVec2f_getOutputData, METH_O, "SoDecomposeVec2f_getOutputData(SoDecomposeVec2f self) -> SoEngineOutputData"},
	 { "SoDecomposeVec2f_createInstance", _wrap_SoDecomposeVec2f_createInstance, METH_NOARGS, "SoDecomposeVec2f_createInstance() -> void *"},
	 { "new_SoDecomposeVec2f", _wrap_new_SoDecomposeVec2f, METH_NOARGS, "new_SoDecomposeVec2f() -> SoDecomposeVec2f"},
	 { "SoDecomposeVec2f_initClass", _wrap_SoDecomposeVec2f_initClass, METH_NOARGS, "SoDecomposeVec2f_initClass()"},
	 { "SoDecomposeVec2f_vector_set", _wrap_SoDecomposeVec2f_vector_set, METH_VARARGS, "SoDecomposeVec2f_vector_set(SoDecomposeVec2f self, SoMFVec2f vector)"},
	 { "SoDecomposeVec2f_vector_get", _wrap_SoDecomposeVec2f_vector_get, METH_O, "SoDecomposeVec2f_vector_get(SoDecomposeVec2f self) -> SoMFVec2f"},
	 { "SoDecomposeVec2f_x_set", _wrap_SoDecomposeVec2f_x_set, METH_VARARGS, "SoDecomposeVec2f_x_set(SoDecomposeVec2f self, SoEngineOutput x)"},
	 { "SoDecomposeVec2f_x_get", _wrap_SoDecomposeVec2f_x_get, METH_O, "SoDecomposeVec2f_x_get(SoDecomposeVec2f self) -> SoEngineOutput"},
	 { "SoDecomposeVec2f_y_set", _wrap_SoDecomposeVec2f_y_set, METH_VARARGS, "SoDecomposeVec2f_y_set(SoDecomposeVec2f self, SoEngineOutput y)"},
	 { "SoDecomposeVec2f_y_get", _wrap_SoDecomposeVec2f_y_get, METH_O, "SoDecomposeVec2f_y_get(SoDecomposeVec2f self) -> SoEngineOutput"},
	 { "SoDecomposeVec2f_swigregister", SoDecomposeVec2f_swigregister, METH_O, NULL},
	 { "SoDecomposeVec2f_swiginit", SoDecomposeVec2f_swiginit, METH_VARARGS, NULL},
	 { "SoDecomposeVec3f_getClassTypeId", _wrap_SoDecomposeVec3f_getClassTypeId, METH_NOARGS, "SoDecomposeVec3f_getClassTypeId() -> SoType"},
	 { "SoDecomposeVec3f_getTypeId", _wrap_SoDecomposeVec3f_getTypeId, METH_O, "SoDecomposeVec3f_getTypeId(SoDecomposeVec3f self) -> SoType"},
	 { "SoDecomposeVec3f_getFieldData", _wrap_SoDecomposeVec3f_getFieldData, METH_O, "SoDecomposeVec3f_getFieldData(SoDecomposeVec3f self) -> SoFieldData"},
	 { "SoDecomposeVec3f_getOutputData", _wrap_SoDecomposeVec3f_getOutputData, METH_O, "SoDecomposeVec3f_getOutputData(SoDecomposeVec3f self) -> SoEngineOutputData"},
	 { "SoDecomposeVec3f_createInstance", _wrap_SoDecomposeVec3f_createInstance, METH_NOARGS, "SoDecomposeVec3f_createInstance() -> void *"},
	 { "new_SoDecomposeVec3f", _wrap_new_SoDecomposeVec3f, METH_NOARGS, "new_SoDecomposeVec3f() -> SoDecomposeVec3f"},
	 { "SoDecomposeVec3f_initClass", _wrap_SoDecomposeVec3f_initClass, METH_NOARGS, "SoDecomposeVec3f_initClass()"},
	 { "SoDecomposeVec3f_vector_set", _wrap_SoDecomposeVec3f_vector_set, METH_VARARGS, "SoDecomposeVec3f_vector_set(SoDecomposeVec3f self, SoMFVec3f vector)"},
	 { "SoDecomposeVec3f_vector_get", _wrap_SoDecomposeVec3f_vector_get, METH_O, "SoDecomposeVec3f_vector_get(SoDecomposeVec3f self) -> SoMFVec3f"},
	 { "SoDecomposeVec3f_x_set", _wrap_SoDecomposeVec3f_x_set, METH_VARARGS, "SoDecomposeVec3f_x_set(SoDecomposeVec3f self, SoEngineOutput x)"},
	 { "SoDecomposeVec3f_x_get", _wrap_SoDecomposeVec3f_x_get, METH_O, "SoDecomposeVec3f_x_get(SoDecomposeVec3f self) -> SoEngineOutput"},
	 { "SoDecomposeVec3f_y_set", _wrap_SoDecomposeVec3f_y_set, METH_VARARGS, "SoDecomposeVec3f_y_set(SoDecomposeVec3f self, SoEngineOutput y)"},
	 { "SoDecomposeVec3f_y_get", _wrap_SoDecomposeVec3f_y_get, METH_O, "SoDecomposeVec3f_y_get(SoDecomposeVec3f self) -> SoEngineOutput"},
	 { "SoDecomposeVec3f_z_set", _wrap_SoDecomposeVec3f_z_set, METH_VARARGS, "SoDecomposeVec3f_z_set(SoDecomposeVec3f self, SoEngineOutput z)"},
	 { "SoDecomposeVec3f_z_get", _wrap_SoDecomposeVec3f_z_get, METH_O, "SoDecomposeVec3f_z_get(SoDecomposeVec3f self) -> SoEngineOutput"},
	 { "SoDecomposeVec3f_swigregister", SoDecomposeVec3f_swigregister, METH_O, NULL},
	 { "SoDecomposeVec3f_swiginit", SoDecomposeVec3f_swiginit, METH_VARARGS, NULL},
	 { "SoDecomposeVec4f_getClassTypeId", _wrap_SoDecomposeVec4f_getClassTypeId, METH_NOARGS, "SoDecomposeVec4f_getClassTypeId() -> SoType"},
	 { "SoDecomposeVec4f_getTypeId", _wrap_SoDecomposeVec4f_getTypeId, METH_O, "SoDecomposeVec4f_getTypeId(SoDecomposeVec4f self) -> SoType"},
	 { "SoDecomposeVec4f_getFieldData", _wrap_SoDecomposeVec4f_getFieldData, METH_O, "SoDecomposeVec4f_getFieldData(SoDecomposeVec4f self) -> SoFieldData"},
	 { "SoDecomposeVec4f_getOutputData", _wrap_SoDecomposeVec4f_getOutputData, METH_O, "SoDecomposeVec4f_getOutputData(SoDecomposeVec4f self) -> SoEngineOutputData"},
	 { "SoDecomposeVec4f_createInstance", _wrap_SoDecomposeVec4f_createInstance, METH_NOARGS, "SoDecomposeVec4f_createInstance() -> void *"},
	 { "new_SoDecomposeVec4f", _wrap_new_SoDecomposeVec4f, METH_NOARGS, "new_SoDecomposeVec4f() -> SoDecomposeVec4f"},
	 { "SoDecomposeVec4f_initClass", _wrap_SoDecomposeVec4f_initClass, METH_NOARGS, "SoDecomposeVec4f_initClass()"},
	 { "SoDecomposeVec4f_vector_set", _wrap_SoDecomposeVec4f_vector_set, METH_VARARGS, "SoDecomposeVec4f_vector_set(SoDecomposeVec4f self, SoMFVec4f vector)"},
	 { "SoDecomposeVec4f_vector_get", _wrap_SoDecomposeVec4f_vector_get, METH_O, "SoDecomposeVec4f_vector_get(SoDecomposeVec4f self) -> SoMFVec4f"},
	 { "SoDecomposeVec4f_x_set", _wrap_SoDecomposeVec4f_x_set, METH_VARARGS, "SoDecomposeVec4f_x_set(SoDecomposeVec4f self, SoEngineOutput x)"},
	 { "SoDecomposeVec4f_x_get", _wrap_SoDecomposeVec4f_x_get, METH_O, "SoDecomposeVec4f_x_get(SoDecomposeVec4f self) -> SoEngineOutput"},
	 { "SoDecomposeVec4f_y_set", _wrap_SoDecomposeVec4f_y_set, METH_VARARGS, "SoDecomposeVec4f_y_set(SoDecomposeVec4f self, SoEngineOutput y)"},
	 { "SoDecomposeVec4f_y_get", _wrap_SoDecomposeVec4f_y_get, METH_O, "SoDecomposeVec4f_y_get(SoDecomposeVec4f self) -> SoEngineOutput"},
	 { "SoDecomposeVec4f_z_set", _wrap_SoDecomposeVec4f_z_set, METH_VARARGS, "SoDecomposeVec4f_z_set(SoDecomposeVec4f self, SoEngineOutput z)"},
	 { "SoDecomposeVec4f_z_get", _wrap_SoDecomposeVec4f_z_get, METH_O, "SoDecomposeVec4f_z_get(SoDecomposeVec4f self) -> SoEngineOutput"},
	 { "SoDecomposeVec4f_w_set", _wrap_SoDecomposeVec4f_w_set, METH_VARARGS, "SoDecomposeVec4f_w_set(SoDecomposeVec4f self, SoEngineOutput w)"},
	 { "SoDecomposeVec4f_w_get", _wrap_SoDecomposeVec4f_w_get, METH_O, "SoDecomposeVec4f_w_get(SoDecomposeVec4f self) -> SoEngineOutput"},
	 { "SoDecomposeVec4f_swigregister", SoDecomposeVec4f_swigregister, METH_O, NULL},
	 { "SoDecomposeVec4f_swiginit", SoDecomposeVec4f_swiginit, METH_VARARGS, NULL},
	 { "SoComposeRotation_getClassTypeId", _wrap_SoComposeRotation_getClassTypeId, METH_NOARGS, "SoComposeRotation_getClassTypeId() -> SoType"},
	 { "SoComposeRotation_getTypeId", _wrap_SoComposeRotation_getTypeId, METH_O, "SoComposeRotation_getTypeId(SoComposeRotation self) -> SoType"},
	 { "SoComposeRotation_getFieldData", _wrap_SoComposeRotation_getFieldData, METH_O, "SoComposeRotation_getFieldData(SoComposeRotation self) -> SoFieldData"},
	 { "SoComposeRotation_getOutputData", _wrap_SoComposeRotation_getOutputData, METH_O, "SoComposeRotation_getOutputData(SoComposeRotation self) -> SoEngineOutputData"},
	 { "SoComposeRotation_createInstance", _wrap_SoComposeRotation_createInstance, METH_NOARGS, "SoComposeRotation_createInstance() -> void *"},
	 { "new_SoComposeRotation", _wrap_new_SoComposeRotation, METH_NOARGS, "new_SoComposeRotation() -> SoComposeRotation"},
	 { "SoComposeRotation_initClass", _wrap_SoComposeRotation_initClass, METH_NOARGS, "SoComposeRotation_initClass()"},
	 { "SoComposeRotation_axis_set", _wrap_SoComposeRotation_axis_set, METH_VARARGS, "SoComposeRotation_axis_set(SoComposeRotation self, SoMFVec3f axis)"},
	 { "SoComposeRotation_axis_get", _wrap_SoComposeRotation_axis_get, METH_O, "SoComposeRotation_axis_get(SoComposeRotation self) -> SoMFVec3f"},
	 { "SoComposeRotation_angle_set", _wrap_SoComposeRotation_angle_set, METH_VARARGS, "SoComposeRotation_angle_set(SoComposeRotation self, SoMFFloat angle)"},
	 { "SoComposeRotation_angle_get", _wrap_SoComposeRotation_angle_get, METH_O, "SoComposeRotation_angle_get(SoComposeRotation self) -> SoMFFloat"},
	 { "SoComposeRotation_rotation_set", _wrap_SoComposeRotation_rotation_set, METH_VARARGS, "SoComposeRotation_rotation_set(SoComposeRotation self, SoEngineOutput rotation)"},
	 { "SoComposeRotation_rotation_get", _wrap_SoComposeRotation_rotation_get, METH_O, "SoComposeRotation_rotation_get(SoComposeRotation self) -> SoEngineOutput"},
	 { "SoComposeRotation_swigregister", SoComposeRotation_swigregister, METH_O, NULL},
	 { "SoComposeRotation_swiginit", SoComposeRotation_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFRotation", _wrap_new_SoMFRotation, METH_NOARGS, "new_SoMFRotation() -> SoMFRotation"},
	 { "delete_SoMFRotation", _wrap_delete_SoMFRotation, METH_O, "delete_SoMFRotation(SoMFRotation self)"},
	 { "SoMFRotation_createInstance", _wrap_SoMFRotation_createInstance, METH_NOARGS, "SoMFRotation_createInstance() -> void *"},
	 { "SoMFRotation_getClassTypeId", _wrap_SoMFRotation_getClassTypeId, METH_NOARGS, "SoMFRotation_getClassTypeId() -> SoType"},
	 { "SoMFRotation_getTypeId", _wrap_SoMFRotation_getTypeId, METH_O, "SoMFRotation_getTypeId(SoMFRotation self) -> SoType"},
	 { "SoMFRotation_copyFrom", _wrap_SoMFRotation_copyFrom, METH_VARARGS, "SoMFRotation_copyFrom(SoMFRotation self, SoField field)"},
	 { "SoMFRotation_isSame", _wrap_SoMFRotation_isSame, METH_VARARGS, "SoMFRotation_isSame(SoMFRotation self, SoField field) -> SbBool"},
	 { "SoMFRotation_find", _wrap_SoMFRotation_find, METH_VARARGS, "SoMFRotation_find(SoMFRotation self, SbRotation value, SbBool addifnotfound=0) -> int"},
	 { "SoMFRotation___eq__", _wrap_SoMFRotation___eq__, METH_VARARGS, "SoMFRotation___eq__(SoMFRotation self, SoMFRotation field) -> SbBool"},
	 { "SoMFRotation___ne__", _wrap_SoMFRotation___ne__, METH_VARARGS, "SoMFRotation___ne__(SoMFRotation self, SoMFRotation field) -> SbBool"},
	 { "SoMFRotation_startEditing", _wrap_SoMFRotation_startEditing, METH_O, "SoMFRotation_startEditing(SoMFRotation self) -> SbRotation"},
	 { "SoMFRotation_finishEditing", _wrap_SoMFRotation_finishEditing, METH_O, "SoMFRotation_finishEditing(SoMFRotation self)"},
	 { "SoMFRotation_initClass", _wrap_SoMFRotation_initClass, METH_NOARGS, "SoMFRotation_initClass()"},
	 { "SoMFRotation_setValues", _wrap_SoMFRotation_setValues, METH_VARARGS, "\n"
		"SoMFRotation_setValues(SoMFRotation self, int const start, int const num, SbRotation newvals)\n"
		"SoMFRotation_setValues(SoMFRotation self, int const start, int const num, float const [][4] q)\n"
		""},
	 { "SoMFRotation_set1Value", _wrap_SoMFRotation_set1Value, METH_VARARGS, "\n"
		"SoMFRotation_set1Value(SoMFRotation self, int const idx, SbRotation value)\n"
		"SoMFRotation_set1Value(SoMFRotation self, int const idx, float const q0, float const q1, float const q2, float const q3)\n"
		"SoMFRotation_set1Value(SoMFRotation self, int const idx, float const [4] q)\n"
		"SoMFRotation_set1Value(SoMFRotation self, int const idx, SbVec3f axis, float const angle)\n"
		""},
	 { "SoMFRotation___getitem__", _wrap_SoMFRotation___getitem__, METH_VARARGS, "SoMFRotation___getitem__(SoMFRotation self, int i) -> SbRotation"},
	 { "SoMFRotation___setitem__", _wrap_SoMFRotation___setitem__, METH_VARARGS, "SoMFRotation___setitem__(SoMFRotation self, int i, SbRotation value)"},
	 { "SoMFRotation_getValues", _wrap_SoMFRotation_getValues, METH_VARARGS, "SoMFRotation_getValues(SoMFRotation self, int i=0) -> SbRotation"},
	 { "SoMFRotation_setValue", _wrap_SoMFRotation_setValue, METH_VARARGS, "\n"
		"SoMFRotation_setValue(SoMFRotation self, SbRotation value)\n"
		"SoMFRotation_setValue(SoMFRotation self, float const q0, float const q1, float const q2, float const q3)\n"
		"SoMFRotation_setValue(SoMFRotation self, float const [4] q)\n"
		"SoMFRotation_setValue(SoMFRotation self, SbVec3f axis, float const angle)\n"
		"SoMFRotation_setValue(SoMFRotation self, SoMFRotation other)\n"
		""},
	 { "SoMFRotation_swigregister", SoMFRotation_swigregister, METH_O, NULL},
	 { "SoMFRotation_swiginit", SoMFRotation_swiginit, METH_VARARGS, NULL},
	 { "SoDecomposeRotation_getClassTypeId", _wrap_SoDecomposeRotation_getClassTypeId, METH_NOARGS, "SoDecomposeRotation_getClassTypeId() -> SoType"},
	 { "SoDecomposeRotation_getTypeId", _wrap_SoDecomposeRotation_getTypeId, METH_O, "SoDecomposeRotation_getTypeId(SoDecomposeRotation self) -> SoType"},
	 { "SoDecomposeRotation_getFieldData", _wrap_SoDecomposeRotation_getFieldData, METH_O, "SoDecomposeRotation_getFieldData(SoDecomposeRotation self) -> SoFieldData"},
	 { "SoDecomposeRotation_getOutputData", _wrap_SoDecomposeRotation_getOutputData, METH_O, "SoDecomposeRotation_getOutputData(SoDecomposeRotation self) -> SoEngineOutputData"},
	 { "SoDecomposeRotation_createInstance", _wrap_SoDecomposeRotation_createInstance, METH_NOARGS, "SoDecomposeRotation_createInstance() -> void *"},
	 { "new_SoDecomposeRotation", _wrap_new_SoDecomposeRotation, METH_NOARGS, "new_SoDecomposeRotation() -> SoDecomposeRotation"},
	 { "SoDecomposeRotation_initClass", _wrap_SoDecomposeRotation_initClass, METH_NOARGS, "SoDecomposeRotation_initClass()"},
	 { "SoDecomposeRotation_rotation_set", _wrap_SoDecomposeRotation_rotation_set, METH_VARARGS, "SoDecomposeRotation_rotation_set(SoDecomposeRotation self, SoMFRotation rotation)"},
	 { "SoDecomposeRotation_rotation_get", _wrap_SoDecomposeRotation_rotation_get, METH_O, "SoDecomposeRotation_rotation_get(SoDecomposeRotation self) -> SoMFRotation"},
	 { "SoDecomposeRotation_axis_set", _wrap_SoDecomposeRotation_axis_set, METH_VARARGS, "SoDecomposeRotation_axis_set(SoDecomposeRotation self, SoEngineOutput axis)"},
	 { "SoDecomposeRotation_axis_get", _wrap_SoDecomposeRotation_axis_get, METH_O, "SoDecomposeRotation_axis_get(SoDecomposeRotation self) -> SoEngineOutput"},
	 { "SoDecomposeRotation_angle_set", _wrap_SoDecomposeRotation_angle_set, METH_VARARGS, "SoDecomposeRotation_angle_set(SoDecomposeRotation self, SoEngineOutput angle)"},
	 { "SoDecomposeRotation_angle_get", _wrap_SoDecomposeRotation_angle_get, METH_O, "SoDecomposeRotation_angle_get(SoDecomposeRotation self) -> SoEngineOutput"},
	 { "SoDecomposeRotation_swigregister", SoDecomposeRotation_swigregister, METH_O, NULL},
	 { "SoDecomposeRotation_swiginit", SoDecomposeRotation_swiginit, METH_VARARGS, NULL},
	 { "SoComposeMatrix_getClassTypeId", _wrap_SoComposeMatrix_getClassTypeId, METH_NOARGS, "SoComposeMatrix_getClassTypeId() -> SoType"},
	 { "SoComposeMatrix_getTypeId", _wrap_SoComposeMatrix_getTypeId, METH_O, "SoComposeMatrix_getTypeId(SoComposeMatrix self) -> SoType"},
	 { "SoComposeMatrix_getFieldData", _wrap_SoComposeMatrix_getFieldData, METH_O, "SoComposeMatrix_getFieldData(SoComposeMatrix self) -> SoFieldData"},
	 { "SoComposeMatrix_getOutputData", _wrap_SoComposeMatrix_getOutputData, METH_O, "SoComposeMatrix_getOutputData(SoComposeMatrix self) -> SoEngineOutputData"},
	 { "SoComposeMatrix_createInstance", _wrap_SoComposeMatrix_createInstance, METH_NOARGS, "SoComposeMatrix_createInstance() -> void *"},
	 { "new_SoComposeMatrix", _wrap_new_SoComposeMatrix, METH_NOARGS, "new_SoComposeMatrix() -> SoComposeMatrix"},
	 { "SoComposeMatrix_initClass", _wrap_SoComposeMatrix_initClass, METH_NOARGS, "SoComposeMatrix_initClass()"},
	 { "SoComposeMatrix_translation_set", _wrap_SoComposeMatrix_translation_set, METH_VARARGS, "SoComposeMatrix_translation_set(SoComposeMatrix self, SoMFVec3f translation)"},
	 { "SoComposeMatrix_translation_get", _wrap_SoComposeMatrix_translation_get, METH_O, "SoComposeMatrix_translation_get(SoComposeMatrix self) -> SoMFVec3f"},
	 { "SoComposeMatrix_rotation_set", _wrap_SoComposeMatrix_rotation_set, METH_VARARGS, "SoComposeMatrix_rotation_set(SoComposeMatrix self, SoMFRotation rotation)"},
	 { "SoComposeMatrix_rotation_get", _wrap_SoComposeMatrix_rotation_get, METH_O, "SoComposeMatrix_rotation_get(SoComposeMatrix self) -> SoMFRotation"},
	 { "SoComposeMatrix_scaleFactor_set", _wrap_SoComposeMatrix_scaleFactor_set, METH_VARARGS, "SoComposeMatrix_scaleFactor_set(SoComposeMatrix self, SoMFVec3f scaleFactor)"},
	 { "SoComposeMatrix_scaleFactor_get", _wrap_SoComposeMatrix_scaleFactor_get, METH_O, "SoComposeMatrix_scaleFactor_get(SoComposeMatrix self) -> SoMFVec3f"},
	 { "SoComposeMatrix_scaleOrientation_set", _wrap_SoComposeMatrix_scaleOrientation_set, METH_VARARGS, "SoComposeMatrix_scaleOrientation_set(SoComposeMatrix self, SoMFRotation scaleOrientation)"},
	 { "SoComposeMatrix_scaleOrientation_get", _wrap_SoComposeMatrix_scaleOrientation_get, METH_O, "SoComposeMatrix_scaleOrientation_get(SoComposeMatrix self) -> SoMFRotation"},
	 { "SoComposeMatrix_center_set", _wrap_SoComposeMatrix_center_set, METH_VARARGS, "SoComposeMatrix_center_set(SoComposeMatrix self, SoMFVec3f center)"},
	 { "SoComposeMatrix_center_get", _wrap_SoComposeMatrix_center_get, METH_O, "SoComposeMatrix_center_get(SoComposeMatrix self) -> SoMFVec3f"},
	 { "SoComposeMatrix_matrix_set", _wrap_SoComposeMatrix_matrix_set, METH_VARARGS, "SoComposeMatrix_matrix_set(SoComposeMatrix self, SoEngineOutput matrix)"},
	 { "SoComposeMatrix_matrix_get", _wrap_SoComposeMatrix_matrix_get, METH_O, "SoComposeMatrix_matrix_get(SoComposeMatrix self) -> SoEngineOutput"},
	 { "SoComposeMatrix_swigregister", SoComposeMatrix_swigregister, METH_O, NULL},
	 { "SoComposeMatrix_swiginit", SoComposeMatrix_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFMatrix", _wrap_new_SoMFMatrix, METH_NOARGS, "new_SoMFMatrix() -> SoMFMatrix"},
	 { "delete_SoMFMatrix", _wrap_delete_SoMFMatrix, METH_O, "delete_SoMFMatrix(SoMFMatrix self)"},
	 { "SoMFMatrix_createInstance", _wrap_SoMFMatrix_createInstance, METH_NOARGS, "SoMFMatrix_createInstance() -> void *"},
	 { "SoMFMatrix_getClassTypeId", _wrap_SoMFMatrix_getClassTypeId, METH_NOARGS, "SoMFMatrix_getClassTypeId() -> SoType"},
	 { "SoMFMatrix_getTypeId", _wrap_SoMFMatrix_getTypeId, METH_O, "SoMFMatrix_getTypeId(SoMFMatrix self) -> SoType"},
	 { "SoMFMatrix_copyFrom", _wrap_SoMFMatrix_copyFrom, METH_VARARGS, "SoMFMatrix_copyFrom(SoMFMatrix self, SoField field)"},
	 { "SoMFMatrix_isSame", _wrap_SoMFMatrix_isSame, METH_VARARGS, "SoMFMatrix_isSame(SoMFMatrix self, SoField field) -> SbBool"},
	 { "SoMFMatrix_find", _wrap_SoMFMatrix_find, METH_VARARGS, "SoMFMatrix_find(SoMFMatrix self, SbMatrix value, SbBool addifnotfound=0) -> int"},
	 { "SoMFMatrix_setValues", _wrap_SoMFMatrix_setValues, METH_VARARGS, "SoMFMatrix_setValues(SoMFMatrix self, int const start, int const num, SbMatrix newvals)"},
	 { "SoMFMatrix_set1Value", _wrap_SoMFMatrix_set1Value, METH_VARARGS, "SoMFMatrix_set1Value(SoMFMatrix self, int const idx, SbMatrix value)"},
	 { "SoMFMatrix___eq__", _wrap_SoMFMatrix___eq__, METH_VARARGS, "SoMFMatrix___eq__(SoMFMatrix self, SoMFMatrix field) -> SbBool"},
	 { "SoMFMatrix___ne__", _wrap_SoMFMatrix___ne__, METH_VARARGS, "SoMFMatrix___ne__(SoMFMatrix self, SoMFMatrix field) -> SbBool"},
	 { "SoMFMatrix_startEditing", _wrap_SoMFMatrix_startEditing, METH_O, "SoMFMatrix_startEditing(SoMFMatrix self) -> SbMatrix"},
	 { "SoMFMatrix_finishEditing", _wrap_SoMFMatrix_finishEditing, METH_O, "SoMFMatrix_finishEditing(SoMFMatrix self)"},
	 { "SoMFMatrix_initClass", _wrap_SoMFMatrix_initClass, METH_NOARGS, "SoMFMatrix_initClass()"},
	 { "SoMFMatrix___getitem__", _wrap_SoMFMatrix___getitem__, METH_VARARGS, "SoMFMatrix___getitem__(SoMFMatrix self, int i) -> SbMatrix"},
	 { "SoMFMatrix___setitem__", _wrap_SoMFMatrix___setitem__, METH_VARARGS, "SoMFMatrix___setitem__(SoMFMatrix self, int i, SbMatrix value)"},
	 { "SoMFMatrix_getValues", _wrap_SoMFMatrix_getValues, METH_VARARGS, "SoMFMatrix_getValues(SoMFMatrix self, int i=0) -> SbMatrix"},
	 { "SoMFMatrix_setValue", _wrap_SoMFMatrix_setValue, METH_VARARGS, "\n"
		"SoMFMatrix_setValue(SoMFMatrix self, SbMatrix value)\n"
		"SoMFMatrix_setValue(SoMFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)\n"
		"SoMFMatrix_setValue(SoMFMatrix self, SoMFMatrix other)\n"
		""},
	 { "SoMFMatrix_swigregister", SoMFMatrix_swigregister, METH_O, NULL},
	 { "SoMFMatrix_swiginit", SoMFMatrix_swiginit, METH_VARARGS, NULL},
	 { "SoDecomposeMatrix_getClassTypeId", _wrap_SoDecomposeMatrix_getClassTypeId, METH_NOARGS, "SoDecomposeMatrix_getClassTypeId() -> SoType"},
	 { "SoDecomposeMatrix_getTypeId", _wrap_SoDecomposeMatrix_getTypeId, METH_O, "SoDecomposeMatrix_getTypeId(SoDecomposeMatrix self) -> SoType"},
	 { "SoDecomposeMatrix_getFieldData", _wrap_SoDecomposeMatrix_getFieldData, METH_O, "SoDecomposeMatrix_getFieldData(SoDecomposeMatrix self) -> SoFieldData"},
	 { "SoDecomposeMatrix_getOutputData", _wrap_SoDecomposeMatrix_getOutputData, METH_O, "SoDecomposeMatrix_getOutputData(SoDecomposeMatrix self) -> SoEngineOutputData"},
	 { "SoDecomposeMatrix_createInstance", _wrap_SoDecomposeMatrix_createInstance, METH_NOARGS, "SoDecomposeMatrix_createInstance() -> void *"},
	 { "new_SoDecomposeMatrix", _wrap_new_SoDecomposeMatrix, METH_NOARGS, "new_SoDecomposeMatrix() -> SoDecomposeMatrix"},
	 { "SoDecomposeMatrix_initClass", _wrap_SoDecomposeMatrix_initClass, METH_NOARGS, "SoDecomposeMatrix_initClass()"},
	 { "SoDecomposeMatrix_matrix_set", _wrap_SoDecomposeMatrix_matrix_set, METH_VARARGS, "SoDecomposeMatrix_matrix_set(SoDecomposeMatrix self, SoMFMatrix matrix)"},
	 { "SoDecomposeMatrix_matrix_get", _wrap_SoDecomposeMatrix_matrix_get, METH_O, "SoDecomposeMatrix_matrix_get(SoDecomposeMatrix self) -> SoMFMatrix"},
	 { "SoDecomposeMatrix_center_set", _wrap_SoDecomposeMatrix_center_set, METH_VARARGS, "SoDecomposeMatrix_center_set(SoDecomposeMatrix self, SoMFVec3f center)"},
	 { "SoDecomposeMatrix_center_get", _wrap_SoDecomposeMatrix_center_get, METH_O, "SoDecomposeMatrix_center_get(SoDecomposeMatrix self) -> SoMFVec3f"},
	 { "SoDecomposeMatrix_translation_set", _wrap_SoDecomposeMatrix_translation_set, METH_VARARGS, "SoDecomposeMatrix_translation_set(SoDecomposeMatrix self, SoEngineOutput translation)"},
	 { "SoDecomposeMatrix_translation_get", _wrap_SoDecomposeMatrix_translation_get, METH_O, "SoDecomposeMatrix_translation_get(SoDecomposeMatrix self) -> SoEngineOutput"},
	 { "SoDecomposeMatrix_rotation_set", _wrap_SoDecomposeMatrix_rotation_set, METH_VARARGS, "SoDecomposeMatrix_rotation_set(SoDecomposeMatrix self, SoEngineOutput rotation)"},
	 { "SoDecomposeMatrix_rotation_get", _wrap_SoDecomposeMatrix_rotation_get, METH_O, "SoDecomposeMatrix_rotation_get(SoDecomposeMatrix self) -> SoEngineOutput"},
	 { "SoDecomposeMatrix_scaleFactor_set", _wrap_SoDecomposeMatrix_scaleFactor_set, METH_VARARGS, "SoDecomposeMatrix_scaleFactor_set(SoDecomposeMatrix self, SoEngineOutput scaleFactor)"},
	 { "SoDecomposeMatrix_scaleFactor_get", _wrap_SoDecomposeMatrix_scaleFactor_get, METH_O, "SoDecomposeMatrix_scaleFactor_get(SoDecomposeMatrix self) -> SoEngineOutput"},
	 { "SoDecomposeMatrix_scaleOrientation_set", _wrap_SoDecomposeMatrix_scaleOrientation_set, METH_VARARGS, "SoDecomposeMatrix_scaleOrientation_set(SoDecomposeMatrix self, SoEngineOutput scaleOrientation)"},
	 { "SoDecomposeMatrix_scaleOrientation_get", _wrap_SoDecomposeMatrix_scaleOrientation_get, METH_O, "SoDecomposeMatrix_scaleOrientation_get(SoDecomposeMatrix self) -> SoEngineOutput"},
	 { "SoDecomposeMatrix_swigregister", SoDecomposeMatrix_swigregister, METH_O, NULL},
	 { "SoDecomposeMatrix_swiginit", SoDecomposeMatrix_swiginit, METH_VARARGS, NULL},
	 { "SoComposeRotationFromTo_getClassTypeId", _wrap_SoComposeRotationFromTo_getClassTypeId, METH_NOARGS, "SoComposeRotationFromTo_getClassTypeId() -> SoType"},
	 { "SoComposeRotationFromTo_getTypeId", _wrap_SoComposeRotationFromTo_getTypeId, METH_O, "SoComposeRotationFromTo_getTypeId(SoComposeRotationFromTo self) -> SoType"},
	 { "SoComposeRotationFromTo_getFieldData", _wrap_SoComposeRotationFromTo_getFieldData, METH_O, "SoComposeRotationFromTo_getFieldData(SoComposeRotationFromTo self) -> SoFieldData"},
	 { "SoComposeRotationFromTo_getOutputData", _wrap_SoComposeRotationFromTo_getOutputData, METH_O, "SoComposeRotationFromTo_getOutputData(SoComposeRotationFromTo self) -> SoEngineOutputData"},
	 { "SoComposeRotationFromTo_createInstance", _wrap_SoComposeRotationFromTo_createInstance, METH_NOARGS, "SoComposeRotationFromTo_createInstance() -> void *"},
	 { "new_SoComposeRotationFromTo", _wrap_new_SoComposeRotationFromTo, METH_NOARGS, "new_SoComposeRotationFromTo() -> SoComposeRotationFromTo"},
	 { "SoComposeRotationFromTo_initClass", _wrap_SoComposeRotationFromTo_initClass, METH_NOARGS, "SoComposeRotationFromTo_initClass()"},
	 { "SoComposeRotationFromTo_srcFrom_set", _wrap_SoComposeRotationFromTo_srcFrom_set, METH_VARARGS, "SoComposeRotationFromTo_srcFrom_set(SoComposeRotationFromTo self, SoMFVec3f srcFrom)"},
	 { "SoComposeRotationFromTo_srcFrom_get", _wrap_SoComposeRotationFromTo_srcFrom_get, METH_O, "SoComposeRotationFromTo_srcFrom_get(SoComposeRotationFromTo self) -> SoMFVec3f"},
	 { "SoComposeRotationFromTo_destTo_set", _wrap_SoComposeRotationFromTo_destTo_set, METH_VARARGS, "SoComposeRotationFromTo_destTo_set(SoComposeRotationFromTo self, SoMFVec3f destTo)"},
	 { "SoComposeRotationFromTo_destTo_get", _wrap_SoComposeRotationFromTo_destTo_get, METH_O, "SoComposeRotationFromTo_destTo_get(SoComposeRotationFromTo self) -> SoMFVec3f"},
	 { "SoComposeRotationFromTo_rotation_set", _wrap_SoComposeRotationFromTo_rotation_set, METH_VARARGS, "SoComposeRotationFromTo_rotation_set(SoComposeRotationFromTo self, SoEngineOutput rotation)"},
	 { "SoComposeRotationFromTo_rotation_get", _wrap_SoComposeRotationFromTo_rotation_get, METH_O, "SoComposeRotationFromTo_rotation_get(SoComposeRotationFromTo self) -> SoEngineOutput"},
	 { "SoComposeRotationFromTo_swigregister", SoComposeRotationFromTo_swigregister, METH_O, NULL},
	 { "SoComposeRotationFromTo_swiginit", SoComposeRotationFromTo_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFPath", _wrap_new_SoSFPath, METH_NOARGS, "new_SoSFPath() -> SoSFPath"},
	 { "delete_SoSFPath", _wrap_delete_SoSFPath, METH_O, "delete_SoSFPath(SoSFPath self)"},
	 { "SoSFPath_createInstance", _wrap_SoSFPath_createInstance, METH_NOARGS, "SoSFPath_createInstance() -> void *"},
	 { "SoSFPath_getClassTypeId", _wrap_SoSFPath_getClassTypeId, METH_NOARGS, "SoSFPath_getClassTypeId() -> SoType"},
	 { "SoSFPath_getTypeId", _wrap_SoSFPath_getTypeId, METH_O, "SoSFPath_getTypeId(SoSFPath self) -> SoType"},
	 { "SoSFPath_copyFrom", _wrap_SoSFPath_copyFrom, METH_VARARGS, "SoSFPath_copyFrom(SoSFPath self, SoField field)"},
	 { "SoSFPath_isSame", _wrap_SoSFPath_isSame, METH_VARARGS, "SoSFPath_isSame(SoSFPath self, SoField field) -> SbBool"},
	 { "SoSFPath_getValue", _wrap_SoSFPath_getValue, METH_O, "SoSFPath_getValue(SoSFPath self) -> SoPath"},
	 { "SoSFPath___eq__", _wrap_SoSFPath___eq__, METH_VARARGS, "SoSFPath___eq__(SoSFPath self, SoSFPath field) -> int"},
	 { "SoSFPath___ne__", _wrap_SoSFPath___ne__, METH_VARARGS, "SoSFPath___ne__(SoSFPath self, SoSFPath field) -> int"},
	 { "SoSFPath_initClass", _wrap_SoSFPath_initClass, METH_NOARGS, "SoSFPath_initClass()"},
	 { "SoSFPath_notify", _wrap_SoSFPath_notify, METH_VARARGS, "SoSFPath_notify(SoSFPath self, SoNotList l)"},
	 { "SoSFPath_fixCopy", _wrap_SoSFPath_fixCopy, METH_VARARGS, "SoSFPath_fixCopy(SoSFPath self, SbBool copyconnections)"},
	 { "SoSFPath_referencesCopy", _wrap_SoSFPath_referencesCopy, METH_O, "SoSFPath_referencesCopy(SoSFPath self) -> SbBool"},
	 { "SoSFPath_setValue", _wrap_SoSFPath_setValue, METH_VARARGS, "\n"
		"SoSFPath_setValue(SoSFPath self, SoPath newvalue)\n"
		"SoSFPath_setValue(SoSFPath self, SoSFPath other)\n"
		""},
	 { "SoSFPath_swigregister", SoSFPath_swigregister, METH_O, NULL},
	 { "SoSFPath_swiginit", SoSFPath_swiginit, METH_VARARGS, NULL},
	 { "SoComputeBoundingBox_getClassTypeId", _wrap_SoComputeBoundingBox_getClassTypeId, METH_NOARGS, "SoComputeBoundingBox_getClassTypeId() -> SoType"},
	 { "SoComputeBoundingBox_getTypeId", _wrap_SoComputeBoundingBox_getTypeId, METH_O, "SoComputeBoundingBox_getTypeId(SoComputeBoundingBox self) -> SoType"},
	 { "SoComputeBoundingBox_getFieldData", _wrap_SoComputeBoundingBox_getFieldData, METH_O, "SoComputeBoundingBox_getFieldData(SoComputeBoundingBox self) -> SoFieldData"},
	 { "SoComputeBoundingBox_getOutputData", _wrap_SoComputeBoundingBox_getOutputData, METH_O, "SoComputeBoundingBox_getOutputData(SoComputeBoundingBox self) -> SoEngineOutputData"},
	 { "SoComputeBoundingBox_createInstance", _wrap_SoComputeBoundingBox_createInstance, METH_NOARGS, "SoComputeBoundingBox_createInstance() -> void *"},
	 { "SoComputeBoundingBox_node_set", _wrap_SoComputeBoundingBox_node_set, METH_VARARGS, "SoComputeBoundingBox_node_set(SoComputeBoundingBox self, SoSFNode node)"},
	 { "SoComputeBoundingBox_node_get", _wrap_SoComputeBoundingBox_node_get, METH_O, "SoComputeBoundingBox_node_get(SoComputeBoundingBox self) -> SoSFNode"},
	 { "SoComputeBoundingBox_path_set", _wrap_SoComputeBoundingBox_path_set, METH_VARARGS, "SoComputeBoundingBox_path_set(SoComputeBoundingBox self, SoSFPath path)"},
	 { "SoComputeBoundingBox_path_get", _wrap_SoComputeBoundingBox_path_get, METH_O, "SoComputeBoundingBox_path_get(SoComputeBoundingBox self) -> SoSFPath"},
	 { "SoComputeBoundingBox_min_set", _wrap_SoComputeBoundingBox_min_set, METH_VARARGS, "SoComputeBoundingBox_min_set(SoComputeBoundingBox self, SoEngineOutput min)"},
	 { "SoComputeBoundingBox_min_get", _wrap_SoComputeBoundingBox_min_get, METH_O, "SoComputeBoundingBox_min_get(SoComputeBoundingBox self) -> SoEngineOutput"},
	 { "SoComputeBoundingBox_max_set", _wrap_SoComputeBoundingBox_max_set, METH_VARARGS, "SoComputeBoundingBox_max_set(SoComputeBoundingBox self, SoEngineOutput max)"},
	 { "SoComputeBoundingBox_max_get", _wrap_SoComputeBoundingBox_max_get, METH_O, "SoComputeBoundingBox_max_get(SoComputeBoundingBox self) -> SoEngineOutput"},
	 { "SoComputeBoundingBox_boxCenter_set", _wrap_SoComputeBoundingBox_boxCenter_set, METH_VARARGS, "SoComputeBoundingBox_boxCenter_set(SoComputeBoundingBox self, SoEngineOutput boxCenter)"},
	 { "SoComputeBoundingBox_boxCenter_get", _wrap_SoComputeBoundingBox_boxCenter_get, METH_O, "SoComputeBoundingBox_boxCenter_get(SoComputeBoundingBox self) -> SoEngineOutput"},
	 { "SoComputeBoundingBox_objectCenter_set", _wrap_SoComputeBoundingBox_objectCenter_set, METH_VARARGS, "SoComputeBoundingBox_objectCenter_set(SoComputeBoundingBox self, SoEngineOutput objectCenter)"},
	 { "SoComputeBoundingBox_objectCenter_get", _wrap_SoComputeBoundingBox_objectCenter_get, METH_O, "SoComputeBoundingBox_objectCenter_get(SoComputeBoundingBox self) -> SoEngineOutput"},
	 { "new_SoComputeBoundingBox", _wrap_new_SoComputeBoundingBox, METH_NOARGS, "new_SoComputeBoundingBox() -> SoComputeBoundingBox"},
	 { "SoComputeBoundingBox_initClass", _wrap_SoComputeBoundingBox_initClass, METH_NOARGS, "SoComputeBoundingBox_initClass()"},
	 { "SoComputeBoundingBox_setViewportRegion", _wrap_SoComputeBoundingBox_setViewportRegion, METH_VARARGS, "SoComputeBoundingBox_setViewportRegion(SoComputeBoundingBox self, SbViewportRegion vpr)"},
	 { "SoComputeBoundingBox_getViewportRegion", _wrap_SoComputeBoundingBox_getViewportRegion, METH_O, "SoComputeBoundingBox_getViewportRegion(SoComputeBoundingBox self) -> SbViewportRegion"},
	 { "SoComputeBoundingBox_swigregister", SoComputeBoundingBox_swigregister, METH_O, NULL},
	 { "SoComputeBoundingBox_swiginit", SoComputeBoundingBox_swiginit, METH_VARARGS, NULL},
	 { "SoConcatenate_getClassTypeId", _wrap_SoConcatenate_getClassTypeId, METH_NOARGS, "SoConcatenate_getClassTypeId() -> SoType"},
	 { "SoConcatenate_getTypeId", _wrap_SoConcatenate_getTypeId, METH_O, "SoConcatenate_getTypeId(SoConcatenate self) -> SoType"},
	 { "SoConcatenate_getFieldData", _wrap_SoConcatenate_getFieldData, METH_O, "SoConcatenate_getFieldData(SoConcatenate self) -> SoFieldData"},
	 { "SoConcatenate_getOutputData", _wrap_SoConcatenate_getOutputData, METH_O, "SoConcatenate_getOutputData(SoConcatenate self) -> SoEngineOutputData"},
	 { "SoConcatenate_createInstance", _wrap_SoConcatenate_createInstance, METH_NOARGS, "SoConcatenate_createInstance() -> void *"},
	 { "SoConcatenate_initClass", _wrap_SoConcatenate_initClass, METH_NOARGS, "SoConcatenate_initClass()"},
	 { "new_SoConcatenate", _wrap_new_SoConcatenate, METH_O, "new_SoConcatenate(SoType inputType) -> SoConcatenate"},
	 { "SoConcatenate_input_set", _wrap_SoConcatenate_input_set, METH_VARARGS, "SoConcatenate_input_set(SoConcatenate self, SoMField *[SoConcatenate::NUMINPUTS] input)"},
	 { "SoConcatenate_input_get", _wrap_SoConcatenate_input_get, METH_O, "SoConcatenate_input_get(SoConcatenate self) -> SoMField *[SoConcatenate::NUMINPUTS]"},
	 { "SoConcatenate_output_set", _wrap_SoConcatenate_output_set, METH_VARARGS, "SoConcatenate_output_set(SoConcatenate self, SoEngineOutput output)"},
	 { "SoConcatenate_output_get", _wrap_SoConcatenate_output_get, METH_O, "SoConcatenate_output_get(SoConcatenate self) -> SoEngineOutput"},
	 { "SoConcatenate_swigregister", SoConcatenate_swigregister, METH_O, NULL},
	 { "SoConcatenate_swiginit", SoConcatenate_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFTrigger", _wrap_new_SoSFTrigger, METH_NOARGS, "new_SoSFTrigger() -> SoSFTrigger"},
	 { "delete_SoSFTrigger", _wrap_delete_SoSFTrigger, METH_O, "delete_SoSFTrigger(SoSFTrigger self)"},
	 { "SoSFTrigger_createInstance", _wrap_SoSFTrigger_createInstance, METH_NOARGS, "SoSFTrigger_createInstance() -> void *"},
	 { "SoSFTrigger_getClassTypeId", _wrap_SoSFTrigger_getClassTypeId, METH_NOARGS, "SoSFTrigger_getClassTypeId() -> SoType"},
	 { "SoSFTrigger_getTypeId", _wrap_SoSFTrigger_getTypeId, METH_O, "SoSFTrigger_getTypeId(SoSFTrigger self) -> SoType"},
	 { "SoSFTrigger_copyFrom", _wrap_SoSFTrigger_copyFrom, METH_VARARGS, "SoSFTrigger_copyFrom(SoSFTrigger self, SoField field)"},
	 { "SoSFTrigger_isSame", _wrap_SoSFTrigger_isSame, METH_VARARGS, "SoSFTrigger_isSame(SoSFTrigger self, SoField field) -> SbBool"},
	 { "SoSFTrigger_initClass", _wrap_SoSFTrigger_initClass, METH_NOARGS, "SoSFTrigger_initClass()"},
	 { "SoSFTrigger_getValue", _wrap_SoSFTrigger_getValue, METH_O, "SoSFTrigger_getValue(SoSFTrigger self)"},
	 { "SoSFTrigger___eq__", _wrap_SoSFTrigger___eq__, METH_VARARGS, "SoSFTrigger___eq__(SoSFTrigger self, SoSFTrigger trigger) -> int"},
	 { "SoSFTrigger___ne__", _wrap_SoSFTrigger___ne__, METH_VARARGS, "SoSFTrigger___ne__(SoSFTrigger self, SoSFTrigger trigger) -> int"},
	 { "SoSFTrigger_startNotify", _wrap_SoSFTrigger_startNotify, METH_O, "SoSFTrigger_startNotify(SoSFTrigger self)"},
	 { "SoSFTrigger_notify", _wrap_SoSFTrigger_notify, METH_VARARGS, "SoSFTrigger_notify(SoSFTrigger self, SoNotList l)"},
	 { "SoSFTrigger_touch", _wrap_SoSFTrigger_touch, METH_O, "SoSFTrigger_touch(SoSFTrigger self)"},
	 { "SoSFTrigger_setValue", _wrap_SoSFTrigger_setValue, METH_VARARGS, "\n"
		"SoSFTrigger_setValue(SoSFTrigger self)\n"
		"SoSFTrigger_setValue(SoSFTrigger self, SoSFTrigger other)\n"
		""},
	 { "SoSFTrigger_swigregister", SoSFTrigger_swigregister, METH_O, NULL},
	 { "SoSFTrigger_swiginit", SoSFTrigger_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFShort", _wrap_new_SoSFShort, METH_NOARGS, "new_SoSFShort() -> SoSFShort"},
	 { "delete_SoSFShort", _wrap_delete_SoSFShort, METH_O, "delete_SoSFShort(SoSFShort self)"},
	 { "SoSFShort_createInstance", _wrap_SoSFShort_createInstance, METH_NOARGS, "SoSFShort_createInstance() -> void *"},
	 { "SoSFShort_getClassTypeId", _wrap_SoSFShort_getClassTypeId, METH_NOARGS, "SoSFShort_getClassTypeId() -> SoType"},
	 { "SoSFShort_getTypeId", _wrap_SoSFShort_getTypeId, METH_O, "SoSFShort_getTypeId(SoSFShort self) -> SoType"},
	 { "SoSFShort_copyFrom", _wrap_SoSFShort_copyFrom, METH_VARARGS, "SoSFShort_copyFrom(SoSFShort self, SoField field)"},
	 { "SoSFShort_isSame", _wrap_SoSFShort_isSame, METH_VARARGS, "SoSFShort_isSame(SoSFShort self, SoField field) -> SbBool"},
	 { "SoSFShort_getValue", _wrap_SoSFShort_getValue, METH_O, "SoSFShort_getValue(SoSFShort self) -> short"},
	 { "SoSFShort___eq__", _wrap_SoSFShort___eq__, METH_VARARGS, "SoSFShort___eq__(SoSFShort self, SoSFShort field) -> int"},
	 { "SoSFShort___ne__", _wrap_SoSFShort___ne__, METH_VARARGS, "SoSFShort___ne__(SoSFShort self, SoSFShort field) -> int"},
	 { "SoSFShort_initClass", _wrap_SoSFShort_initClass, METH_NOARGS, "SoSFShort_initClass()"},
	 { "SoSFShort_setValue", _wrap_SoSFShort_setValue, METH_VARARGS, "\n"
		"SoSFShort_setValue(SoSFShort self, short newvalue)\n"
		"SoSFShort_setValue(SoSFShort self, SoSFShort other)\n"
		""},
	 { "SoSFShort_swigregister", SoSFShort_swigregister, METH_O, NULL},
	 { "SoSFShort_swiginit", SoSFShort_swiginit, METH_VARARGS, NULL},
	 { "SoCounter_getClassTypeId", _wrap_SoCounter_getClassTypeId, METH_NOARGS, "SoCounter_getClassTypeId() -> SoType"},
	 { "SoCounter_getTypeId", _wrap_SoCounter_getTypeId, METH_O, "SoCounter_getTypeId(SoCounter self) -> SoType"},
	 { "SoCounter_getFieldData", _wrap_SoCounter_getFieldData, METH_O, "SoCounter_getFieldData(SoCounter self) -> SoFieldData"},
	 { "SoCounter_getOutputData", _wrap_SoCounter_getOutputData, METH_O, "SoCounter_getOutputData(SoCounter self) -> SoEngineOutputData"},
	 { "SoCounter_createInstance", _wrap_SoCounter_createInstance, METH_NOARGS, "SoCounter_createInstance() -> void *"},
	 { "SoCounter_initClass", _wrap_SoCounter_initClass, METH_NOARGS, "SoCounter_initClass()"},
	 { "new_SoCounter", _wrap_new_SoCounter, METH_NOARGS, "new_SoCounter() -> SoCounter"},
	 { "SoCounter_min_set", _wrap_SoCounter_min_set, METH_VARARGS, "SoCounter_min_set(SoCounter self, SoSFShort min)"},
	 { "SoCounter_min_get", _wrap_SoCounter_min_get, METH_O, "SoCounter_min_get(SoCounter self) -> SoSFShort"},
	 { "SoCounter_max_set", _wrap_SoCounter_max_set, METH_VARARGS, "SoCounter_max_set(SoCounter self, SoSFShort max)"},
	 { "SoCounter_max_get", _wrap_SoCounter_max_get, METH_O, "SoCounter_max_get(SoCounter self) -> SoSFShort"},
	 { "SoCounter_step_set", _wrap_SoCounter_step_set, METH_VARARGS, "SoCounter_step_set(SoCounter self, SoSFShort step)"},
	 { "SoCounter_step_get", _wrap_SoCounter_step_get, METH_O, "SoCounter_step_get(SoCounter self) -> SoSFShort"},
	 { "SoCounter_trigger_set", _wrap_SoCounter_trigger_set, METH_VARARGS, "SoCounter_trigger_set(SoCounter self, SoSFTrigger trigger)"},
	 { "SoCounter_trigger_get", _wrap_SoCounter_trigger_get, METH_O, "SoCounter_trigger_get(SoCounter self) -> SoSFTrigger"},
	 { "SoCounter_reset_set", _wrap_SoCounter_reset_set, METH_VARARGS, "SoCounter_reset_set(SoCounter self, SoSFShort reset)"},
	 { "SoCounter_reset_get", _wrap_SoCounter_reset_get, METH_O, "SoCounter_reset_get(SoCounter self) -> SoSFShort"},
	 { "SoCounter_output_set", _wrap_SoCounter_output_set, METH_VARARGS, "SoCounter_output_set(SoCounter self, SoEngineOutput output)"},
	 { "SoCounter_output_get", _wrap_SoCounter_output_get, METH_O, "SoCounter_output_get(SoCounter self) -> SoEngineOutput"},
	 { "SoCounter_syncOut_set", _wrap_SoCounter_syncOut_set, METH_VARARGS, "SoCounter_syncOut_set(SoCounter self, SoEngineOutput syncOut)"},
	 { "SoCounter_syncOut_get", _wrap_SoCounter_syncOut_get, METH_O, "SoCounter_syncOut_get(SoCounter self) -> SoEngineOutput"},
	 { "SoCounter_swigregister", SoCounter_swigregister, METH_O, NULL},
	 { "SoCounter_swiginit", SoCounter_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFTime", _wrap_new_SoSFTime, METH_NOARGS, "new_SoSFTime() -> SoSFTime"},
	 { "delete_SoSFTime", _wrap_delete_SoSFTime, METH_O, "delete_SoSFTime(SoSFTime self)"},
	 { "SoSFTime_createInstance", _wrap_SoSFTime_createInstance, METH_NOARGS, "SoSFTime_createInstance() -> void *"},
	 { "SoSFTime_getClassTypeId", _wrap_SoSFTime_getClassTypeId, METH_NOARGS, "SoSFTime_getClassTypeId() -> SoType"},
	 { "SoSFTime_getTypeId", _wrap_SoSFTime_getTypeId, METH_O, "SoSFTime_getTypeId(SoSFTime self) -> SoType"},
	 { "SoSFTime_copyFrom", _wrap_SoSFTime_copyFrom, METH_VARARGS, "SoSFTime_copyFrom(SoSFTime self, SoField field)"},
	 { "SoSFTime_isSame", _wrap_SoSFTime_isSame, METH_VARARGS, "SoSFTime_isSame(SoSFTime self, SoField field) -> SbBool"},
	 { "SoSFTime_getValue", _wrap_SoSFTime_getValue, METH_O, "SoSFTime_getValue(SoSFTime self) -> SbTime"},
	 { "SoSFTime___eq__", _wrap_SoSFTime___eq__, METH_VARARGS, "SoSFTime___eq__(SoSFTime self, SoSFTime field) -> int"},
	 { "SoSFTime___ne__", _wrap_SoSFTime___ne__, METH_VARARGS, "SoSFTime___ne__(SoSFTime self, SoSFTime field) -> int"},
	 { "SoSFTime_initClass", _wrap_SoSFTime_initClass, METH_NOARGS, "SoSFTime_initClass()"},
	 { "SoSFTime_setValue", _wrap_SoSFTime_setValue, METH_VARARGS, "\n"
		"SoSFTime_setValue(SoSFTime self, SbTime newvalue)\n"
		"SoSFTime_setValue(SoSFTime self, SbTime other)\n"
		"SoSFTime_setValue(SoSFTime self, SoSFTime other)\n"
		""},
	 { "SoSFTime_swigregister", SoSFTime_swigregister, METH_O, NULL},
	 { "SoSFTime_swiginit", SoSFTime_swiginit, METH_VARARGS, NULL},
	 { "SoElapsedTime_getClassTypeId", _wrap_SoElapsedTime_getClassTypeId, METH_NOARGS, "SoElapsedTime_getClassTypeId() -> SoType"},
	 { "SoElapsedTime_getTypeId", _wrap_SoElapsedTime_getTypeId, METH_O, "SoElapsedTime_getTypeId(SoElapsedTime self) -> SoType"},
	 { "SoElapsedTime_getFieldData", _wrap_SoElapsedTime_getFieldData, METH_O, "SoElapsedTime_getFieldData(SoElapsedTime self) -> SoFieldData"},
	 { "SoElapsedTime_getOutputData", _wrap_SoElapsedTime_getOutputData, METH_O, "SoElapsedTime_getOutputData(SoElapsedTime self) -> SoEngineOutputData"},
	 { "SoElapsedTime_createInstance", _wrap_SoElapsedTime_createInstance, METH_NOARGS, "SoElapsedTime_createInstance() -> void *"},
	 { "SoElapsedTime_initClass", _wrap_SoElapsedTime_initClass, METH_NOARGS, "SoElapsedTime_initClass()"},
	 { "new_SoElapsedTime", _wrap_new_SoElapsedTime, METH_NOARGS, "new_SoElapsedTime() -> SoElapsedTime"},
	 { "SoElapsedTime_timeIn_set", _wrap_SoElapsedTime_timeIn_set, METH_VARARGS, "SoElapsedTime_timeIn_set(SoElapsedTime self, SoSFTime timeIn)"},
	 { "SoElapsedTime_timeIn_get", _wrap_SoElapsedTime_timeIn_get, METH_O, "SoElapsedTime_timeIn_get(SoElapsedTime self) -> SoSFTime"},
	 { "SoElapsedTime_speed_set", _wrap_SoElapsedTime_speed_set, METH_VARARGS, "SoElapsedTime_speed_set(SoElapsedTime self, SoSFFloat speed)"},
	 { "SoElapsedTime_speed_get", _wrap_SoElapsedTime_speed_get, METH_O, "SoElapsedTime_speed_get(SoElapsedTime self) -> SoSFFloat"},
	 { "SoElapsedTime_on_set", _wrap_SoElapsedTime_on_set, METH_VARARGS, "SoElapsedTime_on_set(SoElapsedTime self, SoSFBool on)"},
	 { "SoElapsedTime_on_get", _wrap_SoElapsedTime_on_get, METH_O, "SoElapsedTime_on_get(SoElapsedTime self) -> SoSFBool"},
	 { "SoElapsedTime_pause_set", _wrap_SoElapsedTime_pause_set, METH_VARARGS, "SoElapsedTime_pause_set(SoElapsedTime self, SoSFBool pause)"},
	 { "SoElapsedTime_pause_get", _wrap_SoElapsedTime_pause_get, METH_O, "SoElapsedTime_pause_get(SoElapsedTime self) -> SoSFBool"},
	 { "SoElapsedTime_reset_set", _wrap_SoElapsedTime_reset_set, METH_VARARGS, "SoElapsedTime_reset_set(SoElapsedTime self, SoSFTrigger reset)"},
	 { "SoElapsedTime_reset_get", _wrap_SoElapsedTime_reset_get, METH_O, "SoElapsedTime_reset_get(SoElapsedTime self) -> SoSFTrigger"},
	 { "SoElapsedTime_timeOut_set", _wrap_SoElapsedTime_timeOut_set, METH_VARARGS, "SoElapsedTime_timeOut_set(SoElapsedTime self, SoEngineOutput timeOut)"},
	 { "SoElapsedTime_timeOut_get", _wrap_SoElapsedTime_timeOut_get, METH_O, "SoElapsedTime_timeOut_get(SoElapsedTime self) -> SoEngineOutput"},
	 { "SoElapsedTime_swigregister", SoElapsedTime_swigregister, METH_O, NULL},
	 { "SoElapsedTime_swiginit", SoElapsedTime_swiginit, METH_VARARGS, NULL},
	 { "SoFieldConverter_getClassTypeId", _wrap_SoFieldConverter_getClassTypeId, METH_NOARGS, "SoFieldConverter_getClassTypeId() -> SoType"},
	 { "SoFieldConverter_getTypeId", _wrap_SoFieldConverter_getTypeId, METH_O, "SoFieldConverter_getTypeId(SoFieldConverter self) -> SoType"},
	 { "SoFieldConverter_getFieldData", _wrap_SoFieldConverter_getFieldData, METH_O, "SoFieldConverter_getFieldData(SoFieldConverter self) -> SoFieldData"},
	 { "SoFieldConverter_getOutputData", _wrap_SoFieldConverter_getOutputData, METH_O, "SoFieldConverter_getOutputData(SoFieldConverter self) -> SoEngineOutputData"},
	 { "SoFieldConverter_initClass", _wrap_SoFieldConverter_initClass, METH_NOARGS, "SoFieldConverter_initClass()"},
	 { "SoFieldConverter_initClasses", _wrap_SoFieldConverter_initClasses, METH_NOARGS, "SoFieldConverter_initClasses()"},
	 { "SoFieldConverter_getInput", _wrap_SoFieldConverter_getInput, METH_VARARGS, "SoFieldConverter_getInput(SoFieldConverter self, SoType type) -> SoField"},
	 { "SoFieldConverter_getOutput", _wrap_SoFieldConverter_getOutput, METH_VARARGS, "SoFieldConverter_getOutput(SoFieldConverter self, SoType type) -> SoEngineOutput"},
	 { "SoFieldConverter_getConnectedInput", _wrap_SoFieldConverter_getConnectedInput, METH_O, "SoFieldConverter_getConnectedInput(SoFieldConverter self) -> SoField"},
	 { "SoFieldConverter_getForwardConnections", _wrap_SoFieldConverter_getForwardConnections, METH_VARARGS, "SoFieldConverter_getForwardConnections(SoFieldConverter self, SoFieldList l) -> int"},
	 { "SoFieldConverter_swigregister", SoFieldConverter_swigregister, METH_O, NULL},
	 { "SoGate_getClassTypeId", _wrap_SoGate_getClassTypeId, METH_NOARGS, "SoGate_getClassTypeId() -> SoType"},
	 { "SoGate_getTypeId", _wrap_SoGate_getTypeId, METH_O, "SoGate_getTypeId(SoGate self) -> SoType"},
	 { "SoGate_getFieldData", _wrap_SoGate_getFieldData, METH_O, "SoGate_getFieldData(SoGate self) -> SoFieldData"},
	 { "SoGate_getOutputData", _wrap_SoGate_getOutputData, METH_O, "SoGate_getOutputData(SoGate self) -> SoEngineOutputData"},
	 { "SoGate_createInstance", _wrap_SoGate_createInstance, METH_NOARGS, "SoGate_createInstance() -> void *"},
	 { "SoGate_initClass", _wrap_SoGate_initClass, METH_NOARGS, "SoGate_initClass()"},
	 { "new_SoGate", _wrap_new_SoGate, METH_O, "new_SoGate(SoType type) -> SoGate"},
	 { "SoGate_enable_set", _wrap_SoGate_enable_set, METH_VARARGS, "SoGate_enable_set(SoGate self, SoSFBool enable)"},
	 { "SoGate_enable_get", _wrap_SoGate_enable_get, METH_O, "SoGate_enable_get(SoGate self) -> SoSFBool"},
	 { "SoGate_trigger_set", _wrap_SoGate_trigger_set, METH_VARARGS, "SoGate_trigger_set(SoGate self, SoSFTrigger trigger)"},
	 { "SoGate_trigger_get", _wrap_SoGate_trigger_get, METH_O, "SoGate_trigger_get(SoGate self) -> SoSFTrigger"},
	 { "SoGate_input_set", _wrap_SoGate_input_set, METH_VARARGS, "SoGate_input_set(SoGate self, SoMField input)"},
	 { "SoGate_input_get", _wrap_SoGate_input_get, METH_O, "SoGate_input_get(SoGate self) -> SoMField"},
	 { "SoGate_output_set", _wrap_SoGate_output_set, METH_VARARGS, "SoGate_output_set(SoGate self, SoEngineOutput output)"},
	 { "SoGate_output_get", _wrap_SoGate_output_get, METH_O, "SoGate_output_get(SoGate self) -> SoEngineOutput"},
	 { "SoGate_swigregister", SoGate_swigregister, METH_O, NULL},
	 { "SoGate_swiginit", SoGate_swiginit, METH_VARARGS, NULL},
	 { "SoInterpolate_getClassTypeId", _wrap_SoInterpolate_getClassTypeId, METH_NOARGS, "SoInterpolate_getClassTypeId() -> SoType"},
	 { "SoInterpolate_getTypeId", _wrap_SoInterpolate_getTypeId, METH_O, "SoInterpolate_getTypeId(SoInterpolate self) -> SoType"},
	 { "SoInterpolate_getFieldData", _wrap_SoInterpolate_getFieldData, METH_O, "SoInterpolate_getFieldData(SoInterpolate self) -> SoFieldData"},
	 { "SoInterpolate_getOutputData", _wrap_SoInterpolate_getOutputData, METH_O, "SoInterpolate_getOutputData(SoInterpolate self) -> SoEngineOutputData"},
	 { "SoInterpolate_initClass", _wrap_SoInterpolate_initClass, METH_NOARGS, "SoInterpolate_initClass()"},
	 { "SoInterpolate_initClasses", _wrap_SoInterpolate_initClasses, METH_NOARGS, "SoInterpolate_initClasses()"},
	 { "SoInterpolate_alpha_set", _wrap_SoInterpolate_alpha_set, METH_VARARGS, "SoInterpolate_alpha_set(SoInterpolate self, SoSFFloat alpha)"},
	 { "SoInterpolate_alpha_get", _wrap_SoInterpolate_alpha_get, METH_O, "SoInterpolate_alpha_get(SoInterpolate self) -> SoSFFloat"},
	 { "SoInterpolate_output_set", _wrap_SoInterpolate_output_set, METH_VARARGS, "SoInterpolate_output_set(SoInterpolate self, SoEngineOutput output)"},
	 { "SoInterpolate_output_get", _wrap_SoInterpolate_output_get, METH_O, "SoInterpolate_output_get(SoInterpolate self) -> SoEngineOutput"},
	 { "SoInterpolate_swigregister", SoInterpolate_swigregister, METH_O, NULL},
	 { "SoInterpolateFloat_getClassTypeId", _wrap_SoInterpolateFloat_getClassTypeId, METH_NOARGS, "SoInterpolateFloat_getClassTypeId() -> SoType"},
	 { "SoInterpolateFloat_getTypeId", _wrap_SoInterpolateFloat_getTypeId, METH_O, "SoInterpolateFloat_getTypeId(SoInterpolateFloat self) -> SoType"},
	 { "SoInterpolateFloat_getFieldData", _wrap_SoInterpolateFloat_getFieldData, METH_O, "SoInterpolateFloat_getFieldData(SoInterpolateFloat self) -> SoFieldData"},
	 { "SoInterpolateFloat_getOutputData", _wrap_SoInterpolateFloat_getOutputData, METH_O, "SoInterpolateFloat_getOutputData(SoInterpolateFloat self) -> SoEngineOutputData"},
	 { "SoInterpolateFloat_createInstance", _wrap_SoInterpolateFloat_createInstance, METH_NOARGS, "SoInterpolateFloat_createInstance() -> void *"},
	 { "new_SoInterpolateFloat", _wrap_new_SoInterpolateFloat, METH_NOARGS, "new_SoInterpolateFloat() -> SoInterpolateFloat"},
	 { "SoInterpolateFloat_initClass", _wrap_SoInterpolateFloat_initClass, METH_NOARGS, "SoInterpolateFloat_initClass()"},
	 { "SoInterpolateFloat_input0_set", _wrap_SoInterpolateFloat_input0_set, METH_VARARGS, "SoInterpolateFloat_input0_set(SoInterpolateFloat self, SoMFFloat input0)"},
	 { "SoInterpolateFloat_input0_get", _wrap_SoInterpolateFloat_input0_get, METH_O, "SoInterpolateFloat_input0_get(SoInterpolateFloat self) -> SoMFFloat"},
	 { "SoInterpolateFloat_input1_set", _wrap_SoInterpolateFloat_input1_set, METH_VARARGS, "SoInterpolateFloat_input1_set(SoInterpolateFloat self, SoMFFloat input1)"},
	 { "SoInterpolateFloat_input1_get", _wrap_SoInterpolateFloat_input1_get, METH_O, "SoInterpolateFloat_input1_get(SoInterpolateFloat self) -> SoMFFloat"},
	 { "SoInterpolateFloat_swigregister", SoInterpolateFloat_swigregister, METH_O, NULL},
	 { "SoInterpolateFloat_swiginit", SoInterpolateFloat_swiginit, METH_VARARGS, NULL},
	 { "SoInterpolateVec2f_getClassTypeId", _wrap_SoInterpolateVec2f_getClassTypeId, METH_NOARGS, "SoInterpolateVec2f_getClassTypeId() -> SoType"},
	 { "SoInterpolateVec2f_getTypeId", _wrap_SoInterpolateVec2f_getTypeId, METH_O, "SoInterpolateVec2f_getTypeId(SoInterpolateVec2f self) -> SoType"},
	 { "SoInterpolateVec2f_getFieldData", _wrap_SoInterpolateVec2f_getFieldData, METH_O, "SoInterpolateVec2f_getFieldData(SoInterpolateVec2f self) -> SoFieldData"},
	 { "SoInterpolateVec2f_getOutputData", _wrap_SoInterpolateVec2f_getOutputData, METH_O, "SoInterpolateVec2f_getOutputData(SoInterpolateVec2f self) -> SoEngineOutputData"},
	 { "SoInterpolateVec2f_createInstance", _wrap_SoInterpolateVec2f_createInstance, METH_NOARGS, "SoInterpolateVec2f_createInstance() -> void *"},
	 { "new_SoInterpolateVec2f", _wrap_new_SoInterpolateVec2f, METH_NOARGS, "new_SoInterpolateVec2f() -> SoInterpolateVec2f"},
	 { "SoInterpolateVec2f_initClass", _wrap_SoInterpolateVec2f_initClass, METH_NOARGS, "SoInterpolateVec2f_initClass()"},
	 { "SoInterpolateVec2f_input0_set", _wrap_SoInterpolateVec2f_input0_set, METH_VARARGS, "SoInterpolateVec2f_input0_set(SoInterpolateVec2f self, SoMFVec2f input0)"},
	 { "SoInterpolateVec2f_input0_get", _wrap_SoInterpolateVec2f_input0_get, METH_O, "SoInterpolateVec2f_input0_get(SoInterpolateVec2f self) -> SoMFVec2f"},
	 { "SoInterpolateVec2f_input1_set", _wrap_SoInterpolateVec2f_input1_set, METH_VARARGS, "SoInterpolateVec2f_input1_set(SoInterpolateVec2f self, SoMFVec2f input1)"},
	 { "SoInterpolateVec2f_input1_get", _wrap_SoInterpolateVec2f_input1_get, METH_O, "SoInterpolateVec2f_input1_get(SoInterpolateVec2f self) -> SoMFVec2f"},
	 { "SoInterpolateVec2f_swigregister", SoInterpolateVec2f_swigregister, METH_O, NULL},
	 { "SoInterpolateVec2f_swiginit", SoInterpolateVec2f_swiginit, METH_VARARGS, NULL},
	 { "SoInterpolateVec3f_getClassTypeId", _wrap_SoInterpolateVec3f_getClassTypeId, METH_NOARGS, "SoInterpolateVec3f_getClassTypeId() -> SoType"},
	 { "SoInterpolateVec3f_getTypeId", _wrap_SoInterpolateVec3f_getTypeId, METH_O, "SoInterpolateVec3f_getTypeId(SoInterpolateVec3f self) -> SoType"},
	 { "SoInterpolateVec3f_getFieldData", _wrap_SoInterpolateVec3f_getFieldData, METH_O, "SoInterpolateVec3f_getFieldData(SoInterpolateVec3f self) -> SoFieldData"},
	 { "SoInterpolateVec3f_getOutputData", _wrap_SoInterpolateVec3f_getOutputData, METH_O, "SoInterpolateVec3f_getOutputData(SoInterpolateVec3f self) -> SoEngineOutputData"},
	 { "SoInterpolateVec3f_createInstance", _wrap_SoInterpolateVec3f_createInstance, METH_NOARGS, "SoInterpolateVec3f_createInstance() -> void *"},
	 { "new_SoInterpolateVec3f", _wrap_new_SoInterpolateVec3f, METH_NOARGS, "new_SoInterpolateVec3f() -> SoInterpolateVec3f"},
	 { "SoInterpolateVec3f_initClass", _wrap_SoInterpolateVec3f_initClass, METH_NOARGS, "SoInterpolateVec3f_initClass()"},
	 { "SoInterpolateVec3f_input0_set", _wrap_SoInterpolateVec3f_input0_set, METH_VARARGS, "SoInterpolateVec3f_input0_set(SoInterpolateVec3f self, SoMFVec3f input0)"},
	 { "SoInterpolateVec3f_input0_get", _wrap_SoInterpolateVec3f_input0_get, METH_O, "SoInterpolateVec3f_input0_get(SoInterpolateVec3f self) -> SoMFVec3f"},
	 { "SoInterpolateVec3f_input1_set", _wrap_SoInterpolateVec3f_input1_set, METH_VARARGS, "SoInterpolateVec3f_input1_set(SoInterpolateVec3f self, SoMFVec3f input1)"},
	 { "SoInterpolateVec3f_input1_get", _wrap_SoInterpolateVec3f_input1_get, METH_O, "SoInterpolateVec3f_input1_get(SoInterpolateVec3f self) -> SoMFVec3f"},
	 { "SoInterpolateVec3f_swigregister", SoInterpolateVec3f_swigregister, METH_O, NULL},
	 { "SoInterpolateVec3f_swiginit", SoInterpolateVec3f_swiginit, METH_VARARGS, NULL},
	 { "SoInterpolateVec4f_getClassTypeId", _wrap_SoInterpolateVec4f_getClassTypeId, METH_NOARGS, "SoInterpolateVec4f_getClassTypeId() -> SoType"},
	 { "SoInterpolateVec4f_getTypeId", _wrap_SoInterpolateVec4f_getTypeId, METH_O, "SoInterpolateVec4f_getTypeId(SoInterpolateVec4f self) -> SoType"},
	 { "SoInterpolateVec4f_getFieldData", _wrap_SoInterpolateVec4f_getFieldData, METH_O, "SoInterpolateVec4f_getFieldData(SoInterpolateVec4f self) -> SoFieldData"},
	 { "SoInterpolateVec4f_getOutputData", _wrap_SoInterpolateVec4f_getOutputData, METH_O, "SoInterpolateVec4f_getOutputData(SoInterpolateVec4f self) -> SoEngineOutputData"},
	 { "SoInterpolateVec4f_createInstance", _wrap_SoInterpolateVec4f_createInstance, METH_NOARGS, "SoInterpolateVec4f_createInstance() -> void *"},
	 { "new_SoInterpolateVec4f", _wrap_new_SoInterpolateVec4f, METH_NOARGS, "new_SoInterpolateVec4f() -> SoInterpolateVec4f"},
	 { "SoInterpolateVec4f_initClass", _wrap_SoInterpolateVec4f_initClass, METH_NOARGS, "SoInterpolateVec4f_initClass()"},
	 { "SoInterpolateVec4f_input0_set", _wrap_SoInterpolateVec4f_input0_set, METH_VARARGS, "SoInterpolateVec4f_input0_set(SoInterpolateVec4f self, SoMFVec4f input0)"},
	 { "SoInterpolateVec4f_input0_get", _wrap_SoInterpolateVec4f_input0_get, METH_O, "SoInterpolateVec4f_input0_get(SoInterpolateVec4f self) -> SoMFVec4f"},
	 { "SoInterpolateVec4f_input1_set", _wrap_SoInterpolateVec4f_input1_set, METH_VARARGS, "SoInterpolateVec4f_input1_set(SoInterpolateVec4f self, SoMFVec4f input1)"},
	 { "SoInterpolateVec4f_input1_get", _wrap_SoInterpolateVec4f_input1_get, METH_O, "SoInterpolateVec4f_input1_get(SoInterpolateVec4f self) -> SoMFVec4f"},
	 { "SoInterpolateVec4f_swigregister", SoInterpolateVec4f_swigregister, METH_O, NULL},
	 { "SoInterpolateVec4f_swiginit", SoInterpolateVec4f_swiginit, METH_VARARGS, NULL},
	 { "SoInterpolateRotation_getClassTypeId", _wrap_SoInterpolateRotation_getClassTypeId, METH_NOARGS, "SoInterpolateRotation_getClassTypeId() -> SoType"},
	 { "SoInterpolateRotation_getTypeId", _wrap_SoInterpolateRotation_getTypeId, METH_O, "SoInterpolateRotation_getTypeId(SoInterpolateRotation self) -> SoType"},
	 { "SoInterpolateRotation_getFieldData", _wrap_SoInterpolateRotation_getFieldData, METH_O, "SoInterpolateRotation_getFieldData(SoInterpolateRotation self) -> SoFieldData"},
	 { "SoInterpolateRotation_getOutputData", _wrap_SoInterpolateRotation_getOutputData, METH_O, "SoInterpolateRotation_getOutputData(SoInterpolateRotation self) -> SoEngineOutputData"},
	 { "SoInterpolateRotation_createInstance", _wrap_SoInterpolateRotation_createInstance, METH_NOARGS, "SoInterpolateRotation_createInstance() -> void *"},
	 { "new_SoInterpolateRotation", _wrap_new_SoInterpolateRotation, METH_NOARGS, "new_SoInterpolateRotation() -> SoInterpolateRotation"},
	 { "SoInterpolateRotation_initClass", _wrap_SoInterpolateRotation_initClass, METH_NOARGS, "SoInterpolateRotation_initClass()"},
	 { "SoInterpolateRotation_input0_set", _wrap_SoInterpolateRotation_input0_set, METH_VARARGS, "SoInterpolateRotation_input0_set(SoInterpolateRotation self, SoMFRotation input0)"},
	 { "SoInterpolateRotation_input0_get", _wrap_SoInterpolateRotation_input0_get, METH_O, "SoInterpolateRotation_input0_get(SoInterpolateRotation self) -> SoMFRotation"},
	 { "SoInterpolateRotation_input1_set", _wrap_SoInterpolateRotation_input1_set, METH_VARARGS, "SoInterpolateRotation_input1_set(SoInterpolateRotation self, SoMFRotation input1)"},
	 { "SoInterpolateRotation_input1_get", _wrap_SoInterpolateRotation_input1_get, METH_O, "SoInterpolateRotation_input1_get(SoInterpolateRotation self) -> SoMFRotation"},
	 { "SoInterpolateRotation_swigregister", SoInterpolateRotation_swigregister, METH_O, NULL},
	 { "SoInterpolateRotation_swiginit", SoInterpolateRotation_swiginit, METH_VARARGS, NULL},
	 { "SoOnOff_getClassTypeId", _wrap_SoOnOff_getClassTypeId, METH_NOARGS, "SoOnOff_getClassTypeId() -> SoType"},
	 { "SoOnOff_getTypeId", _wrap_SoOnOff_getTypeId, METH_O, "SoOnOff_getTypeId(SoOnOff self) -> SoType"},
	 { "SoOnOff_getFieldData", _wrap_SoOnOff_getFieldData, METH_O, "SoOnOff_getFieldData(SoOnOff self) -> SoFieldData"},
	 { "SoOnOff_getOutputData", _wrap_SoOnOff_getOutputData, METH_O, "SoOnOff_getOutputData(SoOnOff self) -> SoEngineOutputData"},
	 { "SoOnOff_createInstance", _wrap_SoOnOff_createInstance, METH_NOARGS, "SoOnOff_createInstance() -> void *"},
	 { "SoOnOff_initClass", _wrap_SoOnOff_initClass, METH_NOARGS, "SoOnOff_initClass()"},
	 { "new_SoOnOff", _wrap_new_SoOnOff, METH_NOARGS, "new_SoOnOff() -> SoOnOff"},
	 { "SoOnOff_on_set", _wrap_SoOnOff_on_set, METH_VARARGS, "SoOnOff_on_set(SoOnOff self, SoSFTrigger on)"},
	 { "SoOnOff_on_get", _wrap_SoOnOff_on_get, METH_O, "SoOnOff_on_get(SoOnOff self) -> SoSFTrigger"},
	 { "SoOnOff_off_set", _wrap_SoOnOff_off_set, METH_VARARGS, "SoOnOff_off_set(SoOnOff self, SoSFTrigger off)"},
	 { "SoOnOff_off_get", _wrap_SoOnOff_off_get, METH_O, "SoOnOff_off_get(SoOnOff self) -> SoSFTrigger"},
	 { "SoOnOff_toggle_set", _wrap_SoOnOff_toggle_set, METH_VARARGS, "SoOnOff_toggle_set(SoOnOff self, SoSFTrigger toggle)"},
	 { "SoOnOff_toggle_get", _wrap_SoOnOff_toggle_get, METH_O, "SoOnOff_toggle_get(SoOnOff self) -> SoSFTrigger"},
	 { "SoOnOff_isOn_set", _wrap_SoOnOff_isOn_set, METH_VARARGS, "SoOnOff_isOn_set(SoOnOff self, SoEngineOutput isOn)"},
	 { "SoOnOff_isOn_get", _wrap_SoOnOff_isOn_get, METH_O, "SoOnOff_isOn_get(SoOnOff self) -> SoEngineOutput"},
	 { "SoOnOff_isOff_set", _wrap_SoOnOff_isOff_set, METH_VARARGS, "SoOnOff_isOff_set(SoOnOff self, SoEngineOutput isOff)"},
	 { "SoOnOff_isOff_get", _wrap_SoOnOff_isOff_get, METH_O, "SoOnOff_isOff_get(SoOnOff self) -> SoEngineOutput"},
	 { "SoOnOff_swigregister", SoOnOff_swigregister, METH_O, NULL},
	 { "SoOnOff_swiginit", SoOnOff_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBitMask", _wrap_new_SoSFBitMask, METH_NOARGS, "new_SoSFBitMask() -> SoSFBitMask"},
	 { "delete_SoSFBitMask", _wrap_delete_SoSFBitMask, METH_O, "delete_SoSFBitMask(SoSFBitMask self)"},
	 { "SoSFBitMask_createInstance", _wrap_SoSFBitMask_createInstance, METH_NOARGS, "SoSFBitMask_createInstance() -> void *"},
	 { "SoSFBitMask_getClassTypeId", _wrap_SoSFBitMask_getClassTypeId, METH_NOARGS, "SoSFBitMask_getClassTypeId() -> SoType"},
	 { "SoSFBitMask_getTypeId", _wrap_SoSFBitMask_getTypeId, METH_O, "SoSFBitMask_getTypeId(SoSFBitMask self) -> SoType"},
	 { "SoSFBitMask_copyFrom", _wrap_SoSFBitMask_copyFrom, METH_VARARGS, "SoSFBitMask_copyFrom(SoSFBitMask self, SoField field)"},
	 { "SoSFBitMask_isSame", _wrap_SoSFBitMask_isSame, METH_VARARGS, "SoSFBitMask_isSame(SoSFBitMask self, SoField field) -> SbBool"},
	 { "SoSFBitMask_initClass", _wrap_SoSFBitMask_initClass, METH_NOARGS, "SoSFBitMask_initClass()"},
	 { "SoSFBitMask_swigregister", SoSFBitMask_swigregister, METH_O, NULL},
	 { "SoSFBitMask_swiginit", SoSFBitMask_swiginit, METH_VARARGS, NULL},
	 { "SoOneShot_getClassTypeId", _wrap_SoOneShot_getClassTypeId, METH_NOARGS, "SoOneShot_getClassTypeId() -> SoType"},
	 { "SoOneShot_getTypeId", _wrap_SoOneShot_getTypeId, METH_O, "SoOneShot_getTypeId(SoOneShot self) -> SoType"},
	 { "SoOneShot_getFieldData", _wrap_SoOneShot_getFieldData, METH_O, "SoOneShot_getFieldData(SoOneShot self) -> SoFieldData"},
	 { "SoOneShot_getOutputData", _wrap_SoOneShot_getOutputData, METH_O, "SoOneShot_getOutputData(SoOneShot self) -> SoEngineOutputData"},
	 { "SoOneShot_createInstance", _wrap_SoOneShot_createInstance, METH_NOARGS, "SoOneShot_createInstance() -> void *"},
	 { "SoOneShot_initClass", _wrap_SoOneShot_initClass, METH_NOARGS, "SoOneShot_initClass()"},
	 { "new_SoOneShot", _wrap_new_SoOneShot, METH_NOARGS, "new_SoOneShot() -> SoOneShot"},
	 { "SoOneShot_timeIn_set", _wrap_SoOneShot_timeIn_set, METH_VARARGS, "SoOneShot_timeIn_set(SoOneShot self, SoSFTime timeIn)"},
	 { "SoOneShot_timeIn_get", _wrap_SoOneShot_timeIn_get, METH_O, "SoOneShot_timeIn_get(SoOneShot self) -> SoSFTime"},
	 { "SoOneShot_duration_set", _wrap_SoOneShot_duration_set, METH_VARARGS, "SoOneShot_duration_set(SoOneShot self, SoSFTime duration)"},
	 { "SoOneShot_duration_get", _wrap_SoOneShot_duration_get, METH_O, "SoOneShot_duration_get(SoOneShot self) -> SoSFTime"},
	 { "SoOneShot_trigger_set", _wrap_SoOneShot_trigger_set, METH_VARARGS, "SoOneShot_trigger_set(SoOneShot self, SoSFTrigger trigger)"},
	 { "SoOneShot_trigger_get", _wrap_SoOneShot_trigger_get, METH_O, "SoOneShot_trigger_get(SoOneShot self) -> SoSFTrigger"},
	 { "SoOneShot_flags_set", _wrap_SoOneShot_flags_set, METH_VARARGS, "SoOneShot_flags_set(SoOneShot self, SoSFBitMask flags)"},
	 { "SoOneShot_flags_get", _wrap_SoOneShot_flags_get, METH_O, "SoOneShot_flags_get(SoOneShot self) -> SoSFBitMask"},
	 { "SoOneShot_disable_set", _wrap_SoOneShot_disable_set, METH_VARARGS, "SoOneShot_disable_set(SoOneShot self, SoSFBool disable)"},
	 { "SoOneShot_disable_get", _wrap_SoOneShot_disable_get, METH_O, "SoOneShot_disable_get(SoOneShot self) -> SoSFBool"},
	 { "SoOneShot_timeOut_set", _wrap_SoOneShot_timeOut_set, METH_VARARGS, "SoOneShot_timeOut_set(SoOneShot self, SoEngineOutput timeOut)"},
	 { "SoOneShot_timeOut_get", _wrap_SoOneShot_timeOut_get, METH_O, "SoOneShot_timeOut_get(SoOneShot self) -> SoEngineOutput"},
	 { "SoOneShot_isActive_set", _wrap_SoOneShot_isActive_set, METH_VARARGS, "SoOneShot_isActive_set(SoOneShot self, SoEngineOutput isActive)"},
	 { "SoOneShot_isActive_get", _wrap_SoOneShot_isActive_get, METH_O, "SoOneShot_isActive_get(SoOneShot self) -> SoEngineOutput"},
	 { "SoOneShot_ramp_set", _wrap_SoOneShot_ramp_set, METH_VARARGS, "SoOneShot_ramp_set(SoOneShot self, SoEngineOutput ramp)"},
	 { "SoOneShot_ramp_get", _wrap_SoOneShot_ramp_get, METH_O, "SoOneShot_ramp_get(SoOneShot self) -> SoEngineOutput"},
	 { "SoOneShot_swigregister", SoOneShot_swigregister, METH_O, NULL},
	 { "SoOneShot_swiginit", SoOneShot_swiginit, METH_VARARGS, NULL},
	 { "SoSelectOne_getClassTypeId", _wrap_SoSelectOne_getClassTypeId, METH_NOARGS, "SoSelectOne_getClassTypeId() -> SoType"},
	 { "SoSelectOne_getTypeId", _wrap_SoSelectOne_getTypeId, METH_O, "SoSelectOne_getTypeId(SoSelectOne self) -> SoType"},
	 { "SoSelectOne_getFieldData", _wrap_SoSelectOne_getFieldData, METH_O, "SoSelectOne_getFieldData(SoSelectOne self) -> SoFieldData"},
	 { "SoSelectOne_getOutputData", _wrap_SoSelectOne_getOutputData, METH_O, "SoSelectOne_getOutputData(SoSelectOne self) -> SoEngineOutputData"},
	 { "SoSelectOne_createInstance", _wrap_SoSelectOne_createInstance, METH_NOARGS, "SoSelectOne_createInstance() -> void *"},
	 { "SoSelectOne_index_set", _wrap_SoSelectOne_index_set, METH_VARARGS, "SoSelectOne_index_set(SoSelectOne self, SoSFInt32 index)"},
	 { "SoSelectOne_index_get", _wrap_SoSelectOne_index_get, METH_O, "SoSelectOne_index_get(SoSelectOne self) -> SoSFInt32"},
	 { "SoSelectOne_input_set", _wrap_SoSelectOne_input_set, METH_VARARGS, "SoSelectOne_input_set(SoSelectOne self, SoMField input)"},
	 { "SoSelectOne_input_get", _wrap_SoSelectOne_input_get, METH_O, "SoSelectOne_input_get(SoSelectOne self) -> SoMField"},
	 { "SoSelectOne_output_set", _wrap_SoSelectOne_output_set, METH_VARARGS, "SoSelectOne_output_set(SoSelectOne self, SoEngineOutput output)"},
	 { "SoSelectOne_output_get", _wrap_SoSelectOne_output_get, METH_O, "SoSelectOne_output_get(SoSelectOne self) -> SoEngineOutput"},
	 { "new_SoSelectOne", _wrap_new_SoSelectOne, METH_O, "new_SoSelectOne(SoType inputtype) -> SoSelectOne"},
	 { "SoSelectOne_initClass", _wrap_SoSelectOne_initClass, METH_NOARGS, "SoSelectOne_initClass()"},
	 { "SoSelectOne_swigregister", SoSelectOne_swigregister, METH_O, NULL},
	 { "SoSelectOne_swiginit", SoSelectOne_swiginit, METH_VARARGS, NULL},
	 { "SoTimeCounter_getClassTypeId", _wrap_SoTimeCounter_getClassTypeId, METH_NOARGS, "SoTimeCounter_getClassTypeId() -> SoType"},
	 { "SoTimeCounter_getTypeId", _wrap_SoTimeCounter_getTypeId, METH_O, "SoTimeCounter_getTypeId(SoTimeCounter self) -> SoType"},
	 { "SoTimeCounter_getFieldData", _wrap_SoTimeCounter_getFieldData, METH_O, "SoTimeCounter_getFieldData(SoTimeCounter self) -> SoFieldData"},
	 { "SoTimeCounter_getOutputData", _wrap_SoTimeCounter_getOutputData, METH_O, "SoTimeCounter_getOutputData(SoTimeCounter self) -> SoEngineOutputData"},
	 { "SoTimeCounter_createInstance", _wrap_SoTimeCounter_createInstance, METH_NOARGS, "SoTimeCounter_createInstance() -> void *"},
	 { "SoTimeCounter_timeIn_set", _wrap_SoTimeCounter_timeIn_set, METH_VARARGS, "SoTimeCounter_timeIn_set(SoTimeCounter self, SoSFTime timeIn)"},
	 { "SoTimeCounter_timeIn_get", _wrap_SoTimeCounter_timeIn_get, METH_O, "SoTimeCounter_timeIn_get(SoTimeCounter self) -> SoSFTime"},
	 { "SoTimeCounter_min_set", _wrap_SoTimeCounter_min_set, METH_VARARGS, "SoTimeCounter_min_set(SoTimeCounter self, SoSFShort min)"},
	 { "SoTimeCounter_min_get", _wrap_SoTimeCounter_min_get, METH_O, "SoTimeCounter_min_get(SoTimeCounter self) -> SoSFShort"},
	 { "SoTimeCounter_max_set", _wrap_SoTimeCounter_max_set, METH_VARARGS, "SoTimeCounter_max_set(SoTimeCounter self, SoSFShort max)"},
	 { "SoTimeCounter_max_get", _wrap_SoTimeCounter_max_get, METH_O, "SoTimeCounter_max_get(SoTimeCounter self) -> SoSFShort"},
	 { "SoTimeCounter_step_set", _wrap_SoTimeCounter_step_set, METH_VARARGS, "SoTimeCounter_step_set(SoTimeCounter self, SoSFShort step)"},
	 { "SoTimeCounter_step_get", _wrap_SoTimeCounter_step_get, METH_O, "SoTimeCounter_step_get(SoTimeCounter self) -> SoSFShort"},
	 { "SoTimeCounter_on_set", _wrap_SoTimeCounter_on_set, METH_VARARGS, "SoTimeCounter_on_set(SoTimeCounter self, SoSFBool on)"},
	 { "SoTimeCounter_on_get", _wrap_SoTimeCounter_on_get, METH_O, "SoTimeCounter_on_get(SoTimeCounter self) -> SoSFBool"},
	 { "SoTimeCounter_frequency_set", _wrap_SoTimeCounter_frequency_set, METH_VARARGS, "SoTimeCounter_frequency_set(SoTimeCounter self, SoSFFloat frequency)"},
	 { "SoTimeCounter_frequency_get", _wrap_SoTimeCounter_frequency_get, METH_O, "SoTimeCounter_frequency_get(SoTimeCounter self) -> SoSFFloat"},
	 { "SoTimeCounter_duty_set", _wrap_SoTimeCounter_duty_set, METH_VARARGS, "SoTimeCounter_duty_set(SoTimeCounter self, SoMFFloat duty)"},
	 { "SoTimeCounter_duty_get", _wrap_SoTimeCounter_duty_get, METH_O, "SoTimeCounter_duty_get(SoTimeCounter self) -> SoMFFloat"},
	 { "SoTimeCounter_reset_set", _wrap_SoTimeCounter_reset_set, METH_VARARGS, "SoTimeCounter_reset_set(SoTimeCounter self, SoSFShort reset)"},
	 { "SoTimeCounter_reset_get", _wrap_SoTimeCounter_reset_get, METH_O, "SoTimeCounter_reset_get(SoTimeCounter self) -> SoSFShort"},
	 { "SoTimeCounter_syncIn_set", _wrap_SoTimeCounter_syncIn_set, METH_VARARGS, "SoTimeCounter_syncIn_set(SoTimeCounter self, SoSFTrigger syncIn)"},
	 { "SoTimeCounter_syncIn_get", _wrap_SoTimeCounter_syncIn_get, METH_O, "SoTimeCounter_syncIn_get(SoTimeCounter self) -> SoSFTrigger"},
	 { "SoTimeCounter_output_set", _wrap_SoTimeCounter_output_set, METH_VARARGS, "SoTimeCounter_output_set(SoTimeCounter self, SoEngineOutput output)"},
	 { "SoTimeCounter_output_get", _wrap_SoTimeCounter_output_get, METH_O, "SoTimeCounter_output_get(SoTimeCounter self) -> SoEngineOutput"},
	 { "SoTimeCounter_syncOut_set", _wrap_SoTimeCounter_syncOut_set, METH_VARARGS, "SoTimeCounter_syncOut_set(SoTimeCounter self, SoEngineOutput syncOut)"},
	 { "SoTimeCounter_syncOut_get", _wrap_SoTimeCounter_syncOut_get, METH_O, "SoTimeCounter_syncOut_get(SoTimeCounter self) -> SoEngineOutput"},
	 { "new_SoTimeCounter", _wrap_new_SoTimeCounter, METH_NOARGS, "new_SoTimeCounter() -> SoTimeCounter"},
	 { "SoTimeCounter_initClass", _wrap_SoTimeCounter_initClass, METH_NOARGS, "SoTimeCounter_initClass()"},
	 { "SoTimeCounter_swigregister", SoTimeCounter_swigregister, METH_O, NULL},
	 { "SoTimeCounter_swiginit", SoTimeCounter_swiginit, METH_VARARGS, NULL},
	 { "SoTransformVec3f_getClassTypeId", _wrap_SoTransformVec3f_getClassTypeId, METH_NOARGS, "SoTransformVec3f_getClassTypeId() -> SoType"},
	 { "SoTransformVec3f_getTypeId", _wrap_SoTransformVec3f_getTypeId, METH_O, "SoTransformVec3f_getTypeId(SoTransformVec3f self) -> SoType"},
	 { "SoTransformVec3f_getFieldData", _wrap_SoTransformVec3f_getFieldData, METH_O, "SoTransformVec3f_getFieldData(SoTransformVec3f self) -> SoFieldData"},
	 { "SoTransformVec3f_getOutputData", _wrap_SoTransformVec3f_getOutputData, METH_O, "SoTransformVec3f_getOutputData(SoTransformVec3f self) -> SoEngineOutputData"},
	 { "SoTransformVec3f_createInstance", _wrap_SoTransformVec3f_createInstance, METH_NOARGS, "SoTransformVec3f_createInstance() -> void *"},
	 { "SoTransformVec3f_initClass", _wrap_SoTransformVec3f_initClass, METH_NOARGS, "SoTransformVec3f_initClass()"},
	 { "new_SoTransformVec3f", _wrap_new_SoTransformVec3f, METH_NOARGS, "new_SoTransformVec3f() -> SoTransformVec3f"},
	 { "SoTransformVec3f_vector_set", _wrap_SoTransformVec3f_vector_set, METH_VARARGS, "SoTransformVec3f_vector_set(SoTransformVec3f self, SoMFVec3f vector)"},
	 { "SoTransformVec3f_vector_get", _wrap_SoTransformVec3f_vector_get, METH_O, "SoTransformVec3f_vector_get(SoTransformVec3f self) -> SoMFVec3f"},
	 { "SoTransformVec3f_matrix_set", _wrap_SoTransformVec3f_matrix_set, METH_VARARGS, "SoTransformVec3f_matrix_set(SoTransformVec3f self, SoMFMatrix matrix)"},
	 { "SoTransformVec3f_matrix_get", _wrap_SoTransformVec3f_matrix_get, METH_O, "SoTransformVec3f_matrix_get(SoTransformVec3f self) -> SoMFMatrix"},
	 { "SoTransformVec3f_point_set", _wrap_SoTransformVec3f_point_set, METH_VARARGS, "SoTransformVec3f_point_set(SoTransformVec3f self, SoEngineOutput point)"},
	 { "SoTransformVec3f_point_get", _wrap_SoTransformVec3f_point_get, METH_O, "SoTransformVec3f_point_get(SoTransformVec3f self) -> SoEngineOutput"},
	 { "SoTransformVec3f_direction_set", _wrap_SoTransformVec3f_direction_set, METH_VARARGS, "SoTransformVec3f_direction_set(SoTransformVec3f self, SoEngineOutput direction)"},
	 { "SoTransformVec3f_direction_get", _wrap_SoTransformVec3f_direction_get, METH_O, "SoTransformVec3f_direction_get(SoTransformVec3f self) -> SoEngineOutput"},
	 { "SoTransformVec3f_normalDirection_set", _wrap_SoTransformVec3f_normalDirection_set, METH_VARARGS, "SoTransformVec3f_normalDirection_set(SoTransformVec3f self, SoEngineOutput normalDirection)"},
	 { "SoTransformVec3f_normalDirection_get", _wrap_SoTransformVec3f_normalDirection_get, METH_O, "SoTransformVec3f_normalDirection_get(SoTransformVec3f self) -> SoEngineOutput"},
	 { "SoTransformVec3f_swigregister", SoTransformVec3f_swigregister, METH_O, NULL},
	 { "SoTransformVec3f_swiginit", SoTransformVec3f_swiginit, METH_VARARGS, NULL},
	 { "SoTriggerAny_getClassTypeId", _wrap_SoTriggerAny_getClassTypeId, METH_NOARGS, "SoTriggerAny_getClassTypeId() -> SoType"},
	 { "SoTriggerAny_getTypeId", _wrap_SoTriggerAny_getTypeId, METH_O, "SoTriggerAny_getTypeId(SoTriggerAny self) -> SoType"},
	 { "SoTriggerAny_getFieldData", _wrap_SoTriggerAny_getFieldData, METH_O, "SoTriggerAny_getFieldData(SoTriggerAny self) -> SoFieldData"},
	 { "SoTriggerAny_getOutputData", _wrap_SoTriggerAny_getOutputData, METH_O, "SoTriggerAny_getOutputData(SoTriggerAny self) -> SoEngineOutputData"},
	 { "SoTriggerAny_createInstance", _wrap_SoTriggerAny_createInstance, METH_NOARGS, "SoTriggerAny_createInstance() -> void *"},
	 { "SoTriggerAny_initClass", _wrap_SoTriggerAny_initClass, METH_NOARGS, "SoTriggerAny_initClass()"},
	 { "new_SoTriggerAny", _wrap_new_SoTriggerAny, METH_NOARGS, "new_SoTriggerAny() -> SoTriggerAny"},
	 { "SoTriggerAny_input0_set", _wrap_SoTriggerAny_input0_set, METH_VARARGS, "SoTriggerAny_input0_set(SoTriggerAny self, SoSFTrigger input0)"},
	 { "SoTriggerAny_input0_get", _wrap_SoTriggerAny_input0_get, METH_O, "SoTriggerAny_input0_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input1_set", _wrap_SoTriggerAny_input1_set, METH_VARARGS, "SoTriggerAny_input1_set(SoTriggerAny self, SoSFTrigger input1)"},
	 { "SoTriggerAny_input1_get", _wrap_SoTriggerAny_input1_get, METH_O, "SoTriggerAny_input1_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input2_set", _wrap_SoTriggerAny_input2_set, METH_VARARGS, "SoTriggerAny_input2_set(SoTriggerAny self, SoSFTrigger input2)"},
	 { "SoTriggerAny_input2_get", _wrap_SoTriggerAny_input2_get, METH_O, "SoTriggerAny_input2_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input3_set", _wrap_SoTriggerAny_input3_set, METH_VARARGS, "SoTriggerAny_input3_set(SoTriggerAny self, SoSFTrigger input3)"},
	 { "SoTriggerAny_input3_get", _wrap_SoTriggerAny_input3_get, METH_O, "SoTriggerAny_input3_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input4_set", _wrap_SoTriggerAny_input4_set, METH_VARARGS, "SoTriggerAny_input4_set(SoTriggerAny self, SoSFTrigger input4)"},
	 { "SoTriggerAny_input4_get", _wrap_SoTriggerAny_input4_get, METH_O, "SoTriggerAny_input4_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input5_set", _wrap_SoTriggerAny_input5_set, METH_VARARGS, "SoTriggerAny_input5_set(SoTriggerAny self, SoSFTrigger input5)"},
	 { "SoTriggerAny_input5_get", _wrap_SoTriggerAny_input5_get, METH_O, "SoTriggerAny_input5_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input6_set", _wrap_SoTriggerAny_input6_set, METH_VARARGS, "SoTriggerAny_input6_set(SoTriggerAny self, SoSFTrigger input6)"},
	 { "SoTriggerAny_input6_get", _wrap_SoTriggerAny_input6_get, METH_O, "SoTriggerAny_input6_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input7_set", _wrap_SoTriggerAny_input7_set, METH_VARARGS, "SoTriggerAny_input7_set(SoTriggerAny self, SoSFTrigger input7)"},
	 { "SoTriggerAny_input7_get", _wrap_SoTriggerAny_input7_get, METH_O, "SoTriggerAny_input7_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input8_set", _wrap_SoTriggerAny_input8_set, METH_VARARGS, "SoTriggerAny_input8_set(SoTriggerAny self, SoSFTrigger input8)"},
	 { "SoTriggerAny_input8_get", _wrap_SoTriggerAny_input8_get, METH_O, "SoTriggerAny_input8_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_input9_set", _wrap_SoTriggerAny_input9_set, METH_VARARGS, "SoTriggerAny_input9_set(SoTriggerAny self, SoSFTrigger input9)"},
	 { "SoTriggerAny_input9_get", _wrap_SoTriggerAny_input9_get, METH_O, "SoTriggerAny_input9_get(SoTriggerAny self) -> SoSFTrigger"},
	 { "SoTriggerAny_output_set", _wrap_SoTriggerAny_output_set, METH_VARARGS, "SoTriggerAny_output_set(SoTriggerAny self, SoEngineOutput output)"},
	 { "SoTriggerAny_output_get", _wrap_SoTriggerAny_output_get, METH_O, "SoTriggerAny_output_get(SoTriggerAny self) -> SoEngineOutput"},
	 { "SoTriggerAny_swigregister", SoTriggerAny_swigregister, METH_O, NULL},
	 { "SoTriggerAny_swiginit", SoTriggerAny_swiginit, METH_VARARGS, NULL},
	 { "SoTexture2Convert_getClassTypeId", _wrap_SoTexture2Convert_getClassTypeId, METH_NOARGS, "SoTexture2Convert_getClassTypeId() -> SoType"},
	 { "SoTexture2Convert_getTypeId", _wrap_SoTexture2Convert_getTypeId, METH_O, "SoTexture2Convert_getTypeId(SoTexture2Convert self) -> SoType"},
	 { "SoTexture2Convert_getFieldData", _wrap_SoTexture2Convert_getFieldData, METH_O, "SoTexture2Convert_getFieldData(SoTexture2Convert self) -> SoFieldData"},
	 { "SoTexture2Convert_getOutputData", _wrap_SoTexture2Convert_getOutputData, METH_O, "SoTexture2Convert_getOutputData(SoTexture2Convert self) -> SoEngineOutputData"},
	 { "SoTexture2Convert_initClass", _wrap_SoTexture2Convert_initClass, METH_NOARGS, "SoTexture2Convert_initClass()"},
	 { "SoTexture2Convert_sourceImage_set", _wrap_SoTexture2Convert_sourceImage_set, METH_VARARGS, "SoTexture2Convert_sourceImage_set(SoTexture2Convert self, SoSFImage sourceImage)"},
	 { "SoTexture2Convert_sourceImage_get", _wrap_SoTexture2Convert_sourceImage_get, METH_O, "SoTexture2Convert_sourceImage_get(SoTexture2Convert self) -> SoSFImage"},
	 { "SoTexture2Convert_image_set", _wrap_SoTexture2Convert_image_set, METH_VARARGS, "SoTexture2Convert_image_set(SoTexture2Convert self, SoEngineOutput image)"},
	 { "SoTexture2Convert_image_get", _wrap_SoTexture2Convert_image_get, METH_O, "SoTexture2Convert_image_get(SoTexture2Convert self) -> SoEngineOutput"},
	 { "delete_SoTexture2Convert", _wrap_delete_SoTexture2Convert, METH_O, "delete_SoTexture2Convert(SoTexture2Convert self)"},
	 { "SoTexture2Convert_swigregister", SoTexture2Convert_swigregister, METH_O, NULL},
	 { "SoHeightMapToNormalMap_getClassTypeId", _wrap_SoHeightMapToNormalMap_getClassTypeId, METH_NOARGS, "SoHeightMapToNormalMap_getClassTypeId() -> SoType"},
	 { "SoHeightMapToNormalMap_getTypeId", _wrap_SoHeightMapToNormalMap_getTypeId, METH_O, "SoHeightMapToNormalMap_getTypeId(SoHeightMapToNormalMap self) -> SoType"},
	 { "SoHeightMapToNormalMap_getFieldData", _wrap_SoHeightMapToNormalMap_getFieldData, METH_O, "SoHeightMapToNormalMap_getFieldData(SoHeightMapToNormalMap self) -> SoFieldData"},
	 { "SoHeightMapToNormalMap_getOutputData", _wrap_SoHeightMapToNormalMap_getOutputData, METH_O, "SoHeightMapToNormalMap_getOutputData(SoHeightMapToNormalMap self) -> SoEngineOutputData"},
	 { "SoHeightMapToNormalMap_createInstance", _wrap_SoHeightMapToNormalMap_createInstance, METH_NOARGS, "SoHeightMapToNormalMap_createInstance() -> void *"},
	 { "SoHeightMapToNormalMap_initClass", _wrap_SoHeightMapToNormalMap_initClass, METH_NOARGS, "SoHeightMapToNormalMap_initClass()"},
	 { "new_SoHeightMapToNormalMap", _wrap_new_SoHeightMapToNormalMap, METH_NOARGS, "new_SoHeightMapToNormalMap() -> SoHeightMapToNormalMap"},
	 { "SoHeightMapToNormalMap_format_set", _wrap_SoHeightMapToNormalMap_format_set, METH_VARARGS, "SoHeightMapToNormalMap_format_set(SoHeightMapToNormalMap self, SoSFEnum format)"},
	 { "SoHeightMapToNormalMap_format_get", _wrap_SoHeightMapToNormalMap_format_get, METH_O, "SoHeightMapToNormalMap_format_get(SoHeightMapToNormalMap self) -> SoSFEnum"},
	 { "SoHeightMapToNormalMap_convert", _wrap_SoHeightMapToNormalMap_convert, METH_VARARGS, "SoHeightMapToNormalMap_convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"},
	 { "delete_SoHeightMapToNormalMap", _wrap_delete_SoHeightMapToNormalMap, METH_O, "delete_SoHeightMapToNormalMap(SoHeightMapToNormalMap self)"},
	 { "SoHeightMapToNormalMap_swigregister", SoHeightMapToNormalMap_swigregister, METH_O, NULL},
	 { "SoHeightMapToNormalMap_swiginit", SoHeightMapToNormalMap_swiginit, METH_VARARGS, NULL},
	 { "SoNodeEngine_initClass", _wrap_SoNodeEngine_initClass, METH_NOARGS, "SoNodeEngine_initClass()"},
	 { "SoNodeEngine_getClassTypeId", _wrap_SoNodeEngine_getClassTypeId, METH_NOARGS, "SoNodeEngine_getClassTypeId() -> SoType"},
	 { "SoNodeEngine_evaluateWrapper", _wrap_SoNodeEngine_evaluateWrapper, METH_O, "SoNodeEngine_evaluateWrapper(SoNodeEngine self)"},
	 { "SoNodeEngine_getOutputs", _wrap_SoNodeEngine_getOutputs, METH_VARARGS, "SoNodeEngine_getOutputs(SoNodeEngine self, SoEngineOutputList l) -> int"},
	 { "SoNodeEngine_getOutput", _wrap_SoNodeEngine_getOutput, METH_VARARGS, "SoNodeEngine_getOutput(SoNodeEngine self, SbName outputname) -> SoEngineOutput"},
	 { "SoNodeEngine_getOutputName", _wrap_SoNodeEngine_getOutputName, METH_VARARGS, "SoNodeEngine_getOutputName(SoNodeEngine self, SoEngineOutput output, SbName outputname) -> SbBool"},
	 { "SoNodeEngine_getOutputData", _wrap_SoNodeEngine_getOutputData, METH_O, "SoNodeEngine_getOutputData(SoNodeEngine self) -> SoEngineOutputData"},
	 { "SoNodeEngine_isNotifying", _wrap_SoNodeEngine_isNotifying, METH_O, "SoNodeEngine_isNotifying(SoNodeEngine self) -> SbBool"},
	 { "SoNodeEngine_notify", _wrap_SoNodeEngine_notify, METH_VARARGS, "SoNodeEngine_notify(SoNodeEngine self, SoNotList nl)"},
	 { "SoNodeEngine_writeInstance", _wrap_SoNodeEngine_writeInstance, METH_VARARGS, "SoNodeEngine_writeInstance(SoNodeEngine self, SoOutput out)"},
	 { "SoNodeEngine_swigregister", SoNodeEngine_swigregister, METH_O, NULL},
	 { "SoMemoryError_setHandlerCallback", _wrap_SoMemoryError_setHandlerCallback, METH_VARARGS, "SoMemoryError_setHandlerCallback(SoErrorCB *const callback, void *const data)"},
	 { "SoMemoryError_getHandlerCallback", _wrap_SoMemoryError_getHandlerCallback, METH_NOARGS, "SoMemoryError_getHandlerCallback() -> SoErrorCB *"},
	 { "SoMemoryError_getHandlerData", _wrap_SoMemoryError_getHandlerData, METH_NOARGS, "SoMemoryError_getHandlerData() -> void *"},
	 { "SoMemoryError_getClassTypeId", _wrap_SoMemoryError_getClassTypeId, METH_NOARGS, "SoMemoryError_getClassTypeId() -> SoType"},
	 { "SoMemoryError_getTypeId", _wrap_SoMemoryError_getTypeId, METH_O, "SoMemoryError_getTypeId(SoMemoryError self) -> SoType"},
	 { "SoMemoryError_post", _wrap_SoMemoryError_post, METH_O, "SoMemoryError_post(char const *const whatWasAllocated)"},
	 { "SoMemoryError_initClass", _wrap_SoMemoryError_initClass, METH_NOARGS, "SoMemoryError_initClass()"},
	 { "new_SoMemoryError", _wrap_new_SoMemoryError, METH_NOARGS, "new_SoMemoryError() -> SoMemoryError"},
	 { "delete_SoMemoryError", _wrap_delete_SoMemoryError, METH_O, "delete_SoMemoryError(SoMemoryError self)"},
	 { "SoMemoryError_swigregister", SoMemoryError_swigregister, METH_O, NULL},
	 { "SoMemoryError_swiginit", SoMemoryError_swiginit, METH_VARARGS, NULL},
	 { "SoReadError_setHandlerCallback", _wrap_SoReadError_setHandlerCallback, METH_VARARGS, "SoReadError_setHandlerCallback(SoErrorCB *const function, void *const data)"},
	 { "SoReadError_getHandlerCallback", _wrap_SoReadError_getHandlerCallback, METH_NOARGS, "SoReadError_getHandlerCallback() -> SoErrorCB *"},
	 { "SoReadError_getHandlerData", _wrap_SoReadError_getHandlerData, METH_NOARGS, "SoReadError_getHandlerData() -> void *"},
	 { "SoReadError_getClassTypeId", _wrap_SoReadError_getClassTypeId, METH_NOARGS, "SoReadError_getClassTypeId() -> SoType"},
	 { "SoReadError_getTypeId", _wrap_SoReadError_getTypeId, METH_O, "SoReadError_getTypeId(SoReadError self) -> SoType"},
	 { "SoReadError_post", _wrap_SoReadError_post, METH_VARARGS, "SoReadError_post(SoInput input, char const *const format)"},
	 { "SoReadError_initClass", _wrap_SoReadError_initClass, METH_NOARGS, "SoReadError_initClass()"},
	 { "new_SoReadError", _wrap_new_SoReadError, METH_NOARGS, "new_SoReadError() -> SoReadError"},
	 { "delete_SoReadError", _wrap_delete_SoReadError, METH_O, "delete_SoReadError(SoReadError self)"},
	 { "SoReadError_swigregister", SoReadError_swigregister, METH_O, NULL},
	 { "SoReadError_swiginit", SoReadError_swiginit, METH_VARARGS, NULL},
	 { "SoButtonEvent_getClassTypeId", _wrap_SoButtonEvent_getClassTypeId, METH_NOARGS, "SoButtonEvent_getClassTypeId() -> SoType"},
	 { "SoButtonEvent_getTypeId", _wrap_SoButtonEvent_getTypeId, METH_O, "SoButtonEvent_getTypeId(SoButtonEvent self) -> SoType"},
	 { "SoButtonEvent_initClass", _wrap_SoButtonEvent_initClass, METH_NOARGS, "SoButtonEvent_initClass()"},
	 { "new_SoButtonEvent", _wrap_new_SoButtonEvent, METH_NOARGS, "new_SoButtonEvent() -> SoButtonEvent"},
	 { "delete_SoButtonEvent", _wrap_delete_SoButtonEvent, METH_O, "delete_SoButtonEvent(SoButtonEvent self)"},
	 { "SoButtonEvent_setState", _wrap_SoButtonEvent_setState, METH_VARARGS, "SoButtonEvent_setState(SoButtonEvent self, SoButtonEvent::State state)"},
	 { "SoButtonEvent_getState", _wrap_SoButtonEvent_getState, METH_O, "SoButtonEvent_getState(SoButtonEvent self) -> SoButtonEvent::State"},
	 { "SoButtonEvent_enumToString", _wrap_SoButtonEvent_enumToString, METH_VARARGS, "SoButtonEvent_enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"},
	 { "SoButtonEvent_swigregister", SoButtonEvent_swigregister, METH_O, NULL},
	 { "SoButtonEvent_swiginit", SoButtonEvent_swiginit, METH_VARARGS, NULL},
	 { "SoLocation2Event_getClassTypeId", _wrap_SoLocation2Event_getClassTypeId, METH_NOARGS, "SoLocation2Event_getClassTypeId() -> SoType"},
	 { "SoLocation2Event_getTypeId", _wrap_SoLocation2Event_getTypeId, METH_O, "SoLocation2Event_getTypeId(SoLocation2Event self) -> SoType"},
	 { "SoLocation2Event_initClass", _wrap_SoLocation2Event_initClass, METH_NOARGS, "SoLocation2Event_initClass()"},
	 { "new_SoLocation2Event", _wrap_new_SoLocation2Event, METH_NOARGS, "new_SoLocation2Event() -> SoLocation2Event"},
	 { "delete_SoLocation2Event", _wrap_delete_SoLocation2Event, METH_O, "delete_SoLocation2Event(SoLocation2Event self)"},
	 { "SoLocation2Event_swigregister", SoLocation2Event_swigregister, METH_O, NULL},
	 { "SoLocation2Event_swiginit", SoLocation2Event_swiginit, METH_VARARGS, NULL},
	 { "SoMotion3Event_getClassTypeId", _wrap_SoMotion3Event_getClassTypeId, METH_NOARGS, "SoMotion3Event_getClassTypeId() -> SoType"},
	 { "SoMotion3Event_getTypeId", _wrap_SoMotion3Event_getTypeId, METH_O, "SoMotion3Event_getTypeId(SoMotion3Event self) -> SoType"},
	 { "SoMotion3Event_initClass", _wrap_SoMotion3Event_initClass, METH_NOARGS, "SoMotion3Event_initClass()"},
	 { "new_SoMotion3Event", _wrap_new_SoMotion3Event, METH_NOARGS, "new_SoMotion3Event() -> SoMotion3Event"},
	 { "delete_SoMotion3Event", _wrap_delete_SoMotion3Event, METH_O, "delete_SoMotion3Event(SoMotion3Event self)"},
	 { "SoMotion3Event_setTranslation", _wrap_SoMotion3Event_setTranslation, METH_VARARGS, "SoMotion3Event_setTranslation(SoMotion3Event self, SbVec3f t)"},
	 { "SoMotion3Event_getTranslation", _wrap_SoMotion3Event_getTranslation, METH_O, "SoMotion3Event_getTranslation(SoMotion3Event self) -> SbVec3f"},
	 { "SoMotion3Event_setRotation", _wrap_SoMotion3Event_setRotation, METH_VARARGS, "SoMotion3Event_setRotation(SoMotion3Event self, SbRotation r)"},
	 { "SoMotion3Event_getRotation", _wrap_SoMotion3Event_getRotation, METH_O, "SoMotion3Event_getRotation(SoMotion3Event self) -> SbRotation"},
	 { "SoMotion3Event_swigregister", SoMotion3Event_swigregister, METH_O, NULL},
	 { "SoMotion3Event_swiginit", SoMotion3Event_swiginit, METH_VARARGS, NULL},
	 { "SoKeyboardEvent_getClassTypeId", _wrap_SoKeyboardEvent_getClassTypeId, METH_NOARGS, "SoKeyboardEvent_getClassTypeId() -> SoType"},
	 { "SoKeyboardEvent_getTypeId", _wrap_SoKeyboardEvent_getTypeId, METH_O, "SoKeyboardEvent_getTypeId(SoKeyboardEvent self) -> SoType"},
	 { "SoKeyboardEvent_initClass", _wrap_SoKeyboardEvent_initClass, METH_NOARGS, "SoKeyboardEvent_initClass()"},
	 { "new_SoKeyboardEvent", _wrap_new_SoKeyboardEvent, METH_NOARGS, "new_SoKeyboardEvent() -> SoKeyboardEvent"},
	 { "delete_SoKeyboardEvent", _wrap_delete_SoKeyboardEvent, METH_O, "delete_SoKeyboardEvent(SoKeyboardEvent self)"},
	 { "SoKeyboardEvent_setKey", _wrap_SoKeyboardEvent_setKey, METH_VARARGS, "SoKeyboardEvent_setKey(SoKeyboardEvent self, SoKeyboardEvent::Key key)"},
	 { "SoKeyboardEvent_getKey", _wrap_SoKeyboardEvent_getKey, METH_O, "SoKeyboardEvent_getKey(SoKeyboardEvent self) -> SoKeyboardEvent::Key"},
	 { "SoKeyboardEvent_setPrintableCharacter", _wrap_SoKeyboardEvent_setPrintableCharacter, METH_VARARGS, "SoKeyboardEvent_setPrintableCharacter(SoKeyboardEvent self, char const c)"},
	 { "SoKeyboardEvent_getPrintableCharacter", _wrap_SoKeyboardEvent_getPrintableCharacter, METH_O, "SoKeyboardEvent_getPrintableCharacter(SoKeyboardEvent self) -> char"},
	 { "SoKeyboardEvent_isKeyPressEvent", _wrap_SoKeyboardEvent_isKeyPressEvent, METH_VARARGS, "SoKeyboardEvent_isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"},
	 { "SoKeyboardEvent_isKeyReleaseEvent", _wrap_SoKeyboardEvent_isKeyReleaseEvent, METH_VARARGS, "SoKeyboardEvent_isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"},
	 { "SoKeyboardEvent_enumToString", _wrap_SoKeyboardEvent_enumToString, METH_VARARGS, "SoKeyboardEvent_enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"},
	 { "SoKeyboardEvent_swigregister", SoKeyboardEvent_swigregister, METH_O, NULL},
	 { "SoKeyboardEvent_swiginit", SoKeyboardEvent_swiginit, METH_VARARGS, NULL},
	 { "SoMouseButtonEvent_getClassTypeId", _wrap_SoMouseButtonEvent_getClassTypeId, METH_NOARGS, "SoMouseButtonEvent_getClassTypeId() -> SoType"},
	 { "SoMouseButtonEvent_getTypeId", _wrap_SoMouseButtonEvent_getTypeId, METH_O, "SoMouseButtonEvent_getTypeId(SoMouseButtonEvent self) -> SoType"},
	 { "SoMouseButtonEvent_initClass", _wrap_SoMouseButtonEvent_initClass, METH_NOARGS, "SoMouseButtonEvent_initClass()"},
	 { "new_SoMouseButtonEvent", _wrap_new_SoMouseButtonEvent, METH_NOARGS, "new_SoMouseButtonEvent() -> SoMouseButtonEvent"},
	 { "delete_SoMouseButtonEvent", _wrap_delete_SoMouseButtonEvent, METH_O, "delete_SoMouseButtonEvent(SoMouseButtonEvent self)"},
	 { "SoMouseButtonEvent_setButton", _wrap_SoMouseButtonEvent_setButton, METH_VARARGS, "SoMouseButtonEvent_setButton(SoMouseButtonEvent self, SoMouseButtonEvent::Button button)"},
	 { "SoMouseButtonEvent_getButton", _wrap_SoMouseButtonEvent_getButton, METH_O, "SoMouseButtonEvent_getButton(SoMouseButtonEvent self) -> SoMouseButtonEvent::Button"},
	 { "SoMouseButtonEvent_isButtonPressEvent", _wrap_SoMouseButtonEvent_isButtonPressEvent, METH_VARARGS, "SoMouseButtonEvent_isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"},
	 { "SoMouseButtonEvent_isButtonReleaseEvent", _wrap_SoMouseButtonEvent_isButtonReleaseEvent, METH_VARARGS, "SoMouseButtonEvent_isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"},
	 { "SoMouseButtonEvent_enumToString", _wrap_SoMouseButtonEvent_enumToString, METH_VARARGS, "SoMouseButtonEvent_enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"},
	 { "SoMouseButtonEvent_swigregister", SoMouseButtonEvent_swigregister, METH_O, NULL},
	 { "SoMouseButtonEvent_swiginit", SoMouseButtonEvent_swiginit, METH_VARARGS, NULL},
	 { "SoSpaceballButtonEvent_getClassTypeId", _wrap_SoSpaceballButtonEvent_getClassTypeId, METH_NOARGS, "SoSpaceballButtonEvent_getClassTypeId() -> SoType"},
	 { "SoSpaceballButtonEvent_getTypeId", _wrap_SoSpaceballButtonEvent_getTypeId, METH_O, "SoSpaceballButtonEvent_getTypeId(SoSpaceballButtonEvent self) -> SoType"},
	 { "SoSpaceballButtonEvent_initClass", _wrap_SoSpaceballButtonEvent_initClass, METH_NOARGS, "SoSpaceballButtonEvent_initClass()"},
	 { "new_SoSpaceballButtonEvent", _wrap_new_SoSpaceballButtonEvent, METH_NOARGS, "new_SoSpaceballButtonEvent() -> SoSpaceballButtonEvent"},
	 { "delete_SoSpaceballButtonEvent", _wrap_delete_SoSpaceballButtonEvent, METH_O, "delete_SoSpaceballButtonEvent(SoSpaceballButtonEvent self)"},
	 { "SoSpaceballButtonEvent_setButton", _wrap_SoSpaceballButtonEvent_setButton, METH_VARARGS, "SoSpaceballButtonEvent_setButton(SoSpaceballButtonEvent self, SoSpaceballButtonEvent::Button button)"},
	 { "SoSpaceballButtonEvent_getButton", _wrap_SoSpaceballButtonEvent_getButton, METH_O, "SoSpaceballButtonEvent_getButton(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent::Button"},
	 { "SoSpaceballButtonEvent_isButtonPressEvent", _wrap_SoSpaceballButtonEvent_isButtonPressEvent, METH_VARARGS, "SoSpaceballButtonEvent_isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"},
	 { "SoSpaceballButtonEvent_isButtonReleaseEvent", _wrap_SoSpaceballButtonEvent_isButtonReleaseEvent, METH_VARARGS, "SoSpaceballButtonEvent_isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"},
	 { "SoSpaceballButtonEvent_enumToString", _wrap_SoSpaceballButtonEvent_enumToString, METH_VARARGS, "SoSpaceballButtonEvent_enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"},
	 { "SoSpaceballButtonEvent_swigregister", SoSpaceballButtonEvent_swigregister, METH_O, NULL},
	 { "SoSpaceballButtonEvent_swiginit", SoSpaceballButtonEvent_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox2s", _wrap_new_SbBox2s, METH_VARARGS, "\n"
		"SbBox2s()\n"
		"SbBox2s(short xmin, short ymin, short xmax, short ymax)\n"
		"SbBox2s(SbVec2s minpoint, SbVec2s maxpoint)\n"
		"SbBox2s(SbBox2i32 box)\n"
		"SbBox2s(SbBox2f box)\n"
		"new_SbBox2s(SbBox2d box) -> SbBox2s\n"
		""},
	 { "SbBox2s_setBounds", _wrap_SbBox2s_setBounds, METH_VARARGS, "\n"
		"SbBox2s_setBounds(SbBox2s self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s\n"
		"SbBox2s_setBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s\n"
		"SbBox2s_setBounds(SbBox2s self, SbBox2i32 box) -> SbBox2s\n"
		"SbBox2s_setBounds(SbBox2s self, SbBox2f box) -> SbBox2s\n"
		"SbBox2s_setBounds(SbBox2s self, SbBox2d box) -> SbBox2s\n"
		""},
	 { "SbBox2s_getBounds", _wrap_SbBox2s_getBounds, METH_VARARGS, "\n"
		"SbBox2s_getBounds(SbBox2s self, short & xmin, short & ymin, short & xmax, short & ymax)\n"
		"SbBox2s_getBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint)\n"
		""},
	 { "SbBox2s_getMin", _wrap_SbBox2s_getMin, METH_VARARGS, "\n"
		"SbBox2s_getMin(SbBox2s self) -> SbVec2s\n"
		"SbBox2s_getMin(SbBox2s self) -> SbVec2s\n"
		""},
	 { "SbBox2s_getMax", _wrap_SbBox2s_getMax, METH_VARARGS, "\n"
		"SbBox2s_getMax(SbBox2s self) -> SbVec2s\n"
		"SbBox2s_getMax(SbBox2s self) -> SbVec2s\n"
		""},
	 { "SbBox2s_extendBy", _wrap_SbBox2s_extendBy, METH_VARARGS, "\n"
		"SbBox2s_extendBy(SbBox2s self, SbVec2s point)\n"
		"SbBox2s_extendBy(SbBox2s self, SbBox2s box)\n"
		""},
	 { "SbBox2s_makeEmpty", _wrap_SbBox2s_makeEmpty, METH_O, "SbBox2s_makeEmpty(SbBox2s self)"},
	 { "SbBox2s_isEmpty", _wrap_SbBox2s_isEmpty, METH_O, "SbBox2s_isEmpty(SbBox2s self) -> SbBool"},
	 { "SbBox2s_hasArea", _wrap_SbBox2s_hasArea, METH_O, "SbBox2s_hasArea(SbBox2s self) -> SbBool"},
	 { "SbBox2s_intersect", _wrap_SbBox2s_intersect, METH_VARARGS, "\n"
		"SbBox2s_intersect(SbBox2s self, SbVec2s point) -> SbBool\n"
		"SbBox2s_intersect(SbBox2s self, SbBox2s box) -> SbBool\n"
		""},
	 { "SbBox2s_getCenter", _wrap_SbBox2s_getCenter, METH_O, "SbBox2s_getCenter(SbBox2s self) -> SbVec2f"},
	 { "SbBox2s_getOrigin", _wrap_SbBox2s_getOrigin, METH_VARARGS, "SbBox2s_getOrigin(SbBox2s self, short & originX, short & originY)"},
	 { "SbBox2s_getSize", _wrap_SbBox2s_getSize, METH_VARARGS, "\n"
		"SbBox2s_getSize(SbBox2s self, short & sizeX, short & sizeY)\n"
		"SbBox2s_getSize(SbBox2s self) -> SbVec2s\n"
		""},
	 { "SbBox2s_getAspectRatio", _wrap_SbBox2s_getAspectRatio, METH_O, "SbBox2s_getAspectRatio(SbBox2s self) -> float"},
	 { "SbBox2s___eq__", _wrap_SbBox2s___eq__, METH_VARARGS, "SbBox2s___eq__(SbBox2s self, SbBox2s u) -> int"},
	 { "SbBox2s___ne__", _wrap_SbBox2s___ne__, METH_VARARGS, "SbBox2s___ne__(SbBox2s self, SbBox2s u) -> int"},
	 { "delete_SbBox2s", _wrap_delete_SbBox2s, METH_O, "delete_SbBox2s(SbBox2s self)"},
	 { "SbBox2s_swigregister", SbBox2s_swigregister, METH_O, NULL},
	 { "SbBox2s_swiginit", SbBox2s_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox2s", _wrap_new_SoSFBox2s, METH_NOARGS, "new_SoSFBox2s() -> SoSFBox2s"},
	 { "delete_SoSFBox2s", _wrap_delete_SoSFBox2s, METH_O, "delete_SoSFBox2s(SoSFBox2s self)"},
	 { "SoSFBox2s_createInstance", _wrap_SoSFBox2s_createInstance, METH_NOARGS, "SoSFBox2s_createInstance() -> void *"},
	 { "SoSFBox2s_getClassTypeId", _wrap_SoSFBox2s_getClassTypeId, METH_NOARGS, "SoSFBox2s_getClassTypeId() -> SoType"},
	 { "SoSFBox2s_getTypeId", _wrap_SoSFBox2s_getTypeId, METH_O, "SoSFBox2s_getTypeId(SoSFBox2s self) -> SoType"},
	 { "SoSFBox2s_copyFrom", _wrap_SoSFBox2s_copyFrom, METH_VARARGS, "SoSFBox2s_copyFrom(SoSFBox2s self, SoField field)"},
	 { "SoSFBox2s_isSame", _wrap_SoSFBox2s_isSame, METH_VARARGS, "SoSFBox2s_isSame(SoSFBox2s self, SoField field) -> SbBool"},
	 { "SoSFBox2s___eq__", _wrap_SoSFBox2s___eq__, METH_VARARGS, "SoSFBox2s___eq__(SoSFBox2s self, SoSFBox2s field) -> int"},
	 { "SoSFBox2s___ne__", _wrap_SoSFBox2s___ne__, METH_VARARGS, "SoSFBox2s___ne__(SoSFBox2s self, SoSFBox2s field) -> int"},
	 { "SoSFBox2s_initClass", _wrap_SoSFBox2s_initClass, METH_NOARGS, "SoSFBox2s_initClass()"},
	 { "SoSFBox2s_setValue", _wrap_SoSFBox2s_setValue, METH_VARARGS, "\n"
		"SoSFBox2s_setValue(SoSFBox2s self, SbBox2s newvalue)\n"
		"SoSFBox2s_setValue(SoSFBox2s self, short xmin, short ymin, short xmax, short ymax)\n"
		"SoSFBox2s_setValue(SoSFBox2s self, SbVec2s minvec, SbVec2s maxvec)\n"
		""},
	 { "SoSFBox2s_getValue", _wrap_SoSFBox2s_getValue, METH_VARARGS, "\n"
		"SoSFBox2s_getValue(SoSFBox2s self) -> SbBox2s\n"
		"SoSFBox2s_getValue(SoSFBox2s self, SbBox2s box)\n"
		""},
	 { "SoSFBox2s_swigregister", SoSFBox2s_swigregister, METH_O, NULL},
	 { "SoSFBox2s_swiginit", SoSFBox2s_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec2i32", _wrap_new_SbVec2i32, METH_VARARGS, "\n"
		"SbVec2i32()\n"
		"SbVec2i32(int32_t const [2] v)\n"
		"SbVec2i32(int32_t x, int32_t y)\n"
		"SbVec2i32(SbVec2ui32 const & v)\n"
		"SbVec2i32(SbVec2b v)\n"
		"SbVec2i32(SbVec2s v)\n"
		"SbVec2i32(SbVec2f v)\n"
		"new_SbVec2i32(SbVec2d v) -> SbVec2i32\n"
		""},
	 { "SbVec2i32_setValue", _wrap_SbVec2i32_setValue, METH_VARARGS, "\n"
		"SbVec2i32_setValue(SbVec2i32 self, int32_t const [2] v) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, int32_t x, int32_t y) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, SbVec2ui32 const & v) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, SbVec2b v) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, SbVec2s v) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, SbVec2f v) -> SbVec2i32\n"
		"SbVec2i32_setValue(SbVec2i32 self, SbVec2d v) -> SbVec2i32\n"
		""},
	 { "SbVec2i32_getValue", _wrap_SbVec2i32_getValue, METH_VARARGS, "\n"
		"SbVec2i32_getValue(SbVec2i32 self) -> int32_t const\n"
		"SbVec2i32_getValue(SbVec2i32 self, int32_t & x, int32_t & y)\n"
		""},
	 { "SbVec2i32_dot", _wrap_SbVec2i32_dot, METH_VARARGS, "SbVec2i32_dot(SbVec2i32 self, SbVec2i32 v) -> int32_t"},
	 { "SbVec2i32_negate", _wrap_SbVec2i32_negate, METH_O, "SbVec2i32_negate(SbVec2i32 self)"},
	 { "SbVec2i32___imul__", _wrap_SbVec2i32___imul__, METH_VARARGS, "\n"
		"SbVec2i32___imul__(SbVec2i32 self, int d) -> SbVec2i32\n"
		"SbVec2i32___imul__(SbVec2i32 self, double d) -> SbVec2i32\n"
		""},
	 { "SbVec2i32___itruediv__", _wrap_SbVec2i32___itruediv__, METH_VARARGS, "\n"
		"SbVec2i32___itruediv__(SbVec2i32 self, int d) -> SbVec2i32\n"
		"SbVec2i32___itruediv__(SbVec2i32 self, double d) -> SbVec2i32\n"
		""},
	 { "SbVec2i32___iadd__", _wrap_SbVec2i32___iadd__, METH_VARARGS, "SbVec2i32___iadd__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"},
	 { "SbVec2i32___isub__", _wrap_SbVec2i32___isub__, METH_VARARGS, "SbVec2i32___isub__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"},
	 { "SbVec2i32___neg__", _wrap_SbVec2i32___neg__, METH_O, "SbVec2i32___neg__(SbVec2i32 self) -> SbVec2i32"},
	 { "SbVec2i32_output", _wrap_SbVec2i32_output, METH_VARARGS, "SbVec2i32_output(SbVec2i32 self, FILE * fp)"},
	 { "delete_SbVec2i32", _wrap_delete_SbVec2i32, METH_O, "delete_SbVec2i32(SbVec2i32 self)"},
	 { "SbVec2i32_swigregister", SbVec2i32_swigregister, METH_O, NULL},
	 { "SbVec2i32_swiginit", SbVec2i32_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox2i32", _wrap_new_SbBox2i32, METH_VARARGS, "\n"
		"SbBox2i32()\n"
		"SbBox2i32(int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)\n"
		"SbBox2i32(SbVec2i32 minpoint, SbVec2i32 maxpoint)\n"
		"SbBox2i32(SbBox2s box)\n"
		"SbBox2i32(SbBox2f box)\n"
		"new_SbBox2i32(SbBox2d box) -> SbBox2i32\n"
		""},
	 { "SbBox2i32_setBounds", _wrap_SbBox2i32_setBounds, METH_VARARGS, "\n"
		"SbBox2i32_setBounds(SbBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32\n"
		"SbBox2i32_setBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32\n"
		"SbBox2i32_setBounds(SbBox2i32 self, SbBox2s box) -> SbBox2i32\n"
		"SbBox2i32_setBounds(SbBox2i32 self, SbBox2f box) -> SbBox2i32\n"
		"SbBox2i32_setBounds(SbBox2i32 self, SbBox2d box) -> SbBox2i32\n"
		""},
	 { "SbBox2i32_getBounds", _wrap_SbBox2i32_getBounds, METH_VARARGS, "\n"
		"SbBox2i32_getBounds(SbBox2i32 self, int32_t & xmin, int32_t & ymin, int32_t & xmax, int32_t & ymax)\n"
		"SbBox2i32_getBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint)\n"
		""},
	 { "SbBox2i32_getMin", _wrap_SbBox2i32_getMin, METH_VARARGS, "\n"
		"SbBox2i32_getMin(SbBox2i32 self) -> SbVec2i32\n"
		"SbBox2i32_getMin(SbBox2i32 self) -> SbVec2i32\n"
		""},
	 { "SbBox2i32_getMax", _wrap_SbBox2i32_getMax, METH_VARARGS, "\n"
		"SbBox2i32_getMax(SbBox2i32 self) -> SbVec2i32\n"
		"SbBox2i32_getMax(SbBox2i32 self) -> SbVec2i32\n"
		""},
	 { "SbBox2i32_extendBy", _wrap_SbBox2i32_extendBy, METH_VARARGS, "\n"
		"SbBox2i32_extendBy(SbBox2i32 self, SbVec2i32 point)\n"
		"SbBox2i32_extendBy(SbBox2i32 self, SbBox2i32 box)\n"
		""},
	 { "SbBox2i32_makeEmpty", _wrap_SbBox2i32_makeEmpty, METH_O, "SbBox2i32_makeEmpty(SbBox2i32 self)"},
	 { "SbBox2i32_isEmpty", _wrap_SbBox2i32_isEmpty, METH_O, "SbBox2i32_isEmpty(SbBox2i32 self) -> SbBool"},
	 { "SbBox2i32_hasArea", _wrap_SbBox2i32_hasArea, METH_O, "SbBox2i32_hasArea(SbBox2i32 self) -> SbBool"},
	 { "SbBox2i32_intersect", _wrap_SbBox2i32_intersect, METH_VARARGS, "\n"
		"SbBox2i32_intersect(SbBox2i32 self, SbVec2i32 point) -> SbBool\n"
		"SbBox2i32_intersect(SbBox2i32 self, SbBox2i32 box) -> SbBool\n"
		""},
	 { "SbBox2i32_getCenter", _wrap_SbBox2i32_getCenter, METH_O, "SbBox2i32_getCenter(SbBox2i32 self) -> SbVec2f"},
	 { "SbBox2i32_getOrigin", _wrap_SbBox2i32_getOrigin, METH_VARARGS, "SbBox2i32_getOrigin(SbBox2i32 self, int32_t & originX, int32_t & originY)"},
	 { "SbBox2i32_getSize", _wrap_SbBox2i32_getSize, METH_VARARGS, "\n"
		"SbBox2i32_getSize(SbBox2i32 self, int32_t & sizeX, int32_t & sizeY)\n"
		"SbBox2i32_getSize(SbBox2i32 self) -> SbVec2i32\n"
		""},
	 { "SbBox2i32_getAspectRatio", _wrap_SbBox2i32_getAspectRatio, METH_O, "SbBox2i32_getAspectRatio(SbBox2i32 self) -> float"},
	 { "delete_SbBox2i32", _wrap_delete_SbBox2i32, METH_O, "delete_SbBox2i32(SbBox2i32 self)"},
	 { "SbBox2i32_swigregister", SbBox2i32_swigregister, METH_O, NULL},
	 { "SbBox2i32_swiginit", SbBox2i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox2i32", _wrap_new_SoSFBox2i32, METH_NOARGS, "new_SoSFBox2i32() -> SoSFBox2i32"},
	 { "delete_SoSFBox2i32", _wrap_delete_SoSFBox2i32, METH_O, "delete_SoSFBox2i32(SoSFBox2i32 self)"},
	 { "SoSFBox2i32_createInstance", _wrap_SoSFBox2i32_createInstance, METH_NOARGS, "SoSFBox2i32_createInstance() -> void *"},
	 { "SoSFBox2i32_getClassTypeId", _wrap_SoSFBox2i32_getClassTypeId, METH_NOARGS, "SoSFBox2i32_getClassTypeId() -> SoType"},
	 { "SoSFBox2i32_getTypeId", _wrap_SoSFBox2i32_getTypeId, METH_O, "SoSFBox2i32_getTypeId(SoSFBox2i32 self) -> SoType"},
	 { "SoSFBox2i32_copyFrom", _wrap_SoSFBox2i32_copyFrom, METH_VARARGS, "SoSFBox2i32_copyFrom(SoSFBox2i32 self, SoField field)"},
	 { "SoSFBox2i32_isSame", _wrap_SoSFBox2i32_isSame, METH_VARARGS, "SoSFBox2i32_isSame(SoSFBox2i32 self, SoField field) -> SbBool"},
	 { "SoSFBox2i32___eq__", _wrap_SoSFBox2i32___eq__, METH_VARARGS, "SoSFBox2i32___eq__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"},
	 { "SoSFBox2i32___ne__", _wrap_SoSFBox2i32___ne__, METH_VARARGS, "SoSFBox2i32___ne__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"},
	 { "SoSFBox2i32_initClass", _wrap_SoSFBox2i32_initClass, METH_NOARGS, "SoSFBox2i32_initClass()"},
	 { "SoSFBox2i32_setValue", _wrap_SoSFBox2i32_setValue, METH_VARARGS, "\n"
		"SoSFBox2i32_setValue(SoSFBox2i32 self, SbBox2i32 newvalue)\n"
		"SoSFBox2i32_setValue(SoSFBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)\n"
		"SoSFBox2i32_setValue(SoSFBox2i32 self, SbVec2i32 minvec, SbVec2i32 maxvec)\n"
		""},
	 { "SoSFBox2i32_getValue", _wrap_SoSFBox2i32_getValue, METH_VARARGS, "\n"
		"SoSFBox2i32_getValue(SoSFBox2i32 self) -> SbBox2i32\n"
		"SoSFBox2i32_getValue(SoSFBox2i32 self, SbBox2i32 box)\n"
		""},
	 { "SoSFBox2i32_swigregister", SoSFBox2i32_swigregister, METH_O, NULL},
	 { "SoSFBox2i32_swiginit", SoSFBox2i32_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox2f", _wrap_new_SbBox2f, METH_VARARGS, "\n"
		"SbBox2f()\n"
		"SbBox2f(float xmin, float ymin, float xmax, float ymax)\n"
		"SbBox2f(SbVec2f minpoint, SbVec2f maxpoint)\n"
		"SbBox2f(SbBox2d box)\n"
		"SbBox2f(SbBox2s box)\n"
		"new_SbBox2f(SbBox2i32 box) -> SbBox2f\n"
		""},
	 { "SbBox2f_setBounds", _wrap_SbBox2f_setBounds, METH_VARARGS, "\n"
		"SbBox2f_setBounds(SbBox2f self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f\n"
		"SbBox2f_setBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f\n"
		"SbBox2f_setBounds(SbBox2f self, SbBox2d box) -> SbBox2f\n"
		"SbBox2f_setBounds(SbBox2f self, SbBox2s box) -> SbBox2f\n"
		"SbBox2f_setBounds(SbBox2f self, SbBox2i32 box) -> SbBox2f\n"
		""},
	 { "SbBox2f_getBounds", _wrap_SbBox2f_getBounds, METH_VARARGS, "\n"
		"SbBox2f_getBounds(SbBox2f self, float & xmin, float & ymin, float & xmax, float & ymax)\n"
		"SbBox2f_getBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint)\n"
		""},
	 { "SbBox2f_getMin", _wrap_SbBox2f_getMin, METH_VARARGS, "\n"
		"SbBox2f_getMin(SbBox2f self) -> SbVec2f\n"
		"SbBox2f_getMin(SbBox2f self) -> SbVec2f\n"
		""},
	 { "SbBox2f_getMax", _wrap_SbBox2f_getMax, METH_VARARGS, "\n"
		"SbBox2f_getMax(SbBox2f self) -> SbVec2f\n"
		"SbBox2f_getMax(SbBox2f self) -> SbVec2f\n"
		""},
	 { "SbBox2f_extendBy", _wrap_SbBox2f_extendBy, METH_VARARGS, "\n"
		"SbBox2f_extendBy(SbBox2f self, SbVec2f point)\n"
		"SbBox2f_extendBy(SbBox2f self, SbBox2f box)\n"
		""},
	 { "SbBox2f_makeEmpty", _wrap_SbBox2f_makeEmpty, METH_O, "SbBox2f_makeEmpty(SbBox2f self)"},
	 { "SbBox2f_isEmpty", _wrap_SbBox2f_isEmpty, METH_O, "SbBox2f_isEmpty(SbBox2f self) -> SbBool"},
	 { "SbBox2f_hasArea", _wrap_SbBox2f_hasArea, METH_O, "SbBox2f_hasArea(SbBox2f self) -> SbBool"},
	 { "SbBox2f_intersect", _wrap_SbBox2f_intersect, METH_VARARGS, "\n"
		"SbBox2f_intersect(SbBox2f self, SbVec2f point) -> SbBool\n"
		"SbBox2f_intersect(SbBox2f self, SbBox2f box) -> SbBool\n"
		""},
	 { "SbBox2f_getClosestPoint", _wrap_SbBox2f_getClosestPoint, METH_VARARGS, "SbBox2f_getClosestPoint(SbBox2f self, SbVec2f point) -> SbVec2f"},
	 { "SbBox2f_getCenter", _wrap_SbBox2f_getCenter, METH_O, "SbBox2f_getCenter(SbBox2f self) -> SbVec2f"},
	 { "SbBox2f_getOrigin", _wrap_SbBox2f_getOrigin, METH_VARARGS, "SbBox2f_getOrigin(SbBox2f self, float & originX, float & originY)"},
	 { "SbBox2f_getSize", _wrap_SbBox2f_getSize, METH_VARARGS, "\n"
		"SbBox2f_getSize(SbBox2f self, float & sizeX, float & sizeY)\n"
		"SbBox2f_getSize(SbBox2f self) -> SbVec2f\n"
		""},
	 { "SbBox2f_getAspectRatio", _wrap_SbBox2f_getAspectRatio, METH_O, "SbBox2f_getAspectRatio(SbBox2f self) -> float"},
	 { "SbBox2f___eq__", _wrap_SbBox2f___eq__, METH_VARARGS, "SbBox2f___eq__(SbBox2f self, SbBox2f u) -> int"},
	 { "SbBox2f___ne__", _wrap_SbBox2f___ne__, METH_VARARGS, "SbBox2f___ne__(SbBox2f self, SbBox2f u) -> int"},
	 { "delete_SbBox2f", _wrap_delete_SbBox2f, METH_O, "delete_SbBox2f(SbBox2f self)"},
	 { "SbBox2f_swigregister", SbBox2f_swigregister, METH_O, NULL},
	 { "SbBox2f_swiginit", SbBox2f_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox2f", _wrap_new_SoSFBox2f, METH_NOARGS, "new_SoSFBox2f() -> SoSFBox2f"},
	 { "delete_SoSFBox2f", _wrap_delete_SoSFBox2f, METH_O, "delete_SoSFBox2f(SoSFBox2f self)"},
	 { "SoSFBox2f_createInstance", _wrap_SoSFBox2f_createInstance, METH_NOARGS, "SoSFBox2f_createInstance() -> void *"},
	 { "SoSFBox2f_getClassTypeId", _wrap_SoSFBox2f_getClassTypeId, METH_NOARGS, "SoSFBox2f_getClassTypeId() -> SoType"},
	 { "SoSFBox2f_getTypeId", _wrap_SoSFBox2f_getTypeId, METH_O, "SoSFBox2f_getTypeId(SoSFBox2f self) -> SoType"},
	 { "SoSFBox2f_copyFrom", _wrap_SoSFBox2f_copyFrom, METH_VARARGS, "SoSFBox2f_copyFrom(SoSFBox2f self, SoField field)"},
	 { "SoSFBox2f_isSame", _wrap_SoSFBox2f_isSame, METH_VARARGS, "SoSFBox2f_isSame(SoSFBox2f self, SoField field) -> SbBool"},
	 { "SoSFBox2f___eq__", _wrap_SoSFBox2f___eq__, METH_VARARGS, "SoSFBox2f___eq__(SoSFBox2f self, SoSFBox2f field) -> int"},
	 { "SoSFBox2f___ne__", _wrap_SoSFBox2f___ne__, METH_VARARGS, "SoSFBox2f___ne__(SoSFBox2f self, SoSFBox2f field) -> int"},
	 { "SoSFBox2f_initClass", _wrap_SoSFBox2f_initClass, METH_NOARGS, "SoSFBox2f_initClass()"},
	 { "SoSFBox2f_setValue", _wrap_SoSFBox2f_setValue, METH_VARARGS, "\n"
		"SoSFBox2f_setValue(SoSFBox2f self, SbBox2f newvalue)\n"
		"SoSFBox2f_setValue(SoSFBox2f self, float xmin, float ymin, float xmax, float ymax)\n"
		"SoSFBox2f_setValue(SoSFBox2f self, SbVec2f minvec, SbVec2f maxvec)\n"
		""},
	 { "SoSFBox2f_getValue", _wrap_SoSFBox2f_getValue, METH_VARARGS, "\n"
		"SoSFBox2f_getValue(SoSFBox2f self) -> SbBox2f\n"
		"SoSFBox2f_getValue(SoSFBox2f self, SbBox2f box)\n"
		""},
	 { "SoSFBox2f_swigregister", SoSFBox2f_swigregister, METH_O, NULL},
	 { "SoSFBox2f_swiginit", SoSFBox2f_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec2d", _wrap_new_SbVec2d, METH_VARARGS, "\n"
		"SbVec2d()\n"
		"SbVec2d(double const [2] v)\n"
		"SbVec2d(double x, double y)\n"
		"SbVec2d(SbVec2f v)\n"
		"SbVec2d(SbVec2b v)\n"
		"SbVec2d(SbVec2s v)\n"
		"new_SbVec2d(SbVec2i32 v) -> SbVec2d\n"
		""},
	 { "SbVec2d_setValue", _wrap_SbVec2d_setValue, METH_VARARGS, "\n"
		"SbVec2d_setValue(SbVec2d self, double const [2] v) -> SbVec2d\n"
		"SbVec2d_setValue(SbVec2d self, double x, double y) -> SbVec2d\n"
		"SbVec2d_setValue(SbVec2d self, SbVec2f v) -> SbVec2d\n"
		"SbVec2d_setValue(SbVec2d self, SbVec2b v) -> SbVec2d\n"
		"SbVec2d_setValue(SbVec2d self, SbVec2s v) -> SbVec2d\n"
		"SbVec2d_setValue(SbVec2d self, SbVec2i32 v) -> SbVec2d\n"
		""},
	 { "SbVec2d_getValue", _wrap_SbVec2d_getValue, METH_O, "SbVec2d_getValue(SbVec2d self)"},
	 { "SbVec2d_equals", _wrap_SbVec2d_equals, METH_VARARGS, "SbVec2d_equals(SbVec2d self, SbVec2d v, double tolerance) -> SbBool"},
	 { "SbVec2d_dot", _wrap_SbVec2d_dot, METH_VARARGS, "SbVec2d_dot(SbVec2d self, SbVec2d v) -> double"},
	 { "SbVec2d_length", _wrap_SbVec2d_length, METH_O, "SbVec2d_length(SbVec2d self) -> double"},
	 { "SbVec2d_sqrLength", _wrap_SbVec2d_sqrLength, METH_O, "SbVec2d_sqrLength(SbVec2d self) -> double"},
	 { "SbVec2d_normalize", _wrap_SbVec2d_normalize, METH_O, "SbVec2d_normalize(SbVec2d self) -> double"},
	 { "SbVec2d_negate", _wrap_SbVec2d_negate, METH_O, "SbVec2d_negate(SbVec2d self)"},
	 { "SbVec2d___imul__", _wrap_SbVec2d___imul__, METH_VARARGS, "SbVec2d___imul__(SbVec2d self, double d) -> SbVec2d"},
	 { "SbVec2d___itruediv__", _wrap_SbVec2d___itruediv__, METH_VARARGS, "SbVec2d___itruediv__(SbVec2d self, double d) -> SbVec2d"},
	 { "SbVec2d___iadd__", _wrap_SbVec2d___iadd__, METH_VARARGS, "SbVec2d___iadd__(SbVec2d self, SbVec2d v) -> SbVec2d"},
	 { "SbVec2d___isub__", _wrap_SbVec2d___isub__, METH_VARARGS, "SbVec2d___isub__(SbVec2d self, SbVec2d v) -> SbVec2d"},
	 { "SbVec2d___neg__", _wrap_SbVec2d___neg__, METH_O, "SbVec2d___neg__(SbVec2d self) -> SbVec2d"},
	 { "SbVec2d_output", _wrap_SbVec2d_output, METH_VARARGS, "SbVec2d_output(SbVec2d self, FILE * fp)"},
	 { "SbVec2d___add__", _wrap_SbVec2d___add__, METH_VARARGS, "SbVec2d___add__(SbVec2d self, SbVec2d u) -> SbVec2d"},
	 { "SbVec2d___sub__", _wrap_SbVec2d___sub__, METH_VARARGS, "SbVec2d___sub__(SbVec2d self, SbVec2d u) -> SbVec2d"},
	 { "SbVec2d___mul__", _wrap_SbVec2d___mul__, METH_VARARGS, "SbVec2d___mul__(SbVec2d self, float const d) -> SbVec2d"},
	 { "SbVec2d___rmul__", _wrap_SbVec2d___rmul__, METH_VARARGS, "SbVec2d___rmul__(SbVec2d self, float const d) -> SbVec2d"},
	 { "SbVec2d___div__", _wrap_SbVec2d___div__, METH_VARARGS, "SbVec2d___div__(SbVec2d self, float const d) -> SbVec2d"},
	 { "SbVec2d___truediv__", _wrap_SbVec2d___truediv__, METH_VARARGS, "SbVec2d___truediv__(SbVec2d self, float const d) -> SbVec2d"},
	 { "SbVec2d___eq__", _wrap_SbVec2d___eq__, METH_VARARGS, "SbVec2d___eq__(SbVec2d self, SbVec2d u) -> int"},
	 { "SbVec2d___nq__", _wrap_SbVec2d___nq__, METH_VARARGS, "SbVec2d___nq__(SbVec2d self, SbVec2d u) -> int"},
	 { "SbVec2d___getitem__", _wrap_SbVec2d___getitem__, METH_VARARGS, "SbVec2d___getitem__(SbVec2d self, int i) -> double"},
	 { "SbVec2d___setitem__", _wrap_SbVec2d___setitem__, METH_VARARGS, "SbVec2d___setitem__(SbVec2d self, int i, double value)"},
	 { "delete_SbVec2d", _wrap_delete_SbVec2d, METH_O, "delete_SbVec2d(SbVec2d self)"},
	 { "SbVec2d_swigregister", SbVec2d_swigregister, METH_O, NULL},
	 { "SbVec2d_swiginit", SbVec2d_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox2d", _wrap_new_SbBox2d, METH_VARARGS, "\n"
		"SbBox2d()\n"
		"SbBox2d(double xmin, double ymin, double xmax, double ymax)\n"
		"SbBox2d(SbVec2d minpoint, SbVec2d maxpoint)\n"
		"SbBox2d(SbBox2f box)\n"
		"SbBox2d(SbBox2s box)\n"
		"new_SbBox2d(SbBox2i32 box) -> SbBox2d\n"
		""},
	 { "SbBox2d_setBounds", _wrap_SbBox2d_setBounds, METH_VARARGS, "\n"
		"SbBox2d_setBounds(SbBox2d self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d\n"
		"SbBox2d_setBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d\n"
		"SbBox2d_setBounds(SbBox2d self, SbBox2f box) -> SbBox2d\n"
		"SbBox2d_setBounds(SbBox2d self, SbBox2s box) -> SbBox2d\n"
		"SbBox2d_setBounds(SbBox2d self, SbBox2i32 box) -> SbBox2d\n"
		""},
	 { "SbBox2d_getBounds", _wrap_SbBox2d_getBounds, METH_VARARGS, "\n"
		"SbBox2d_getBounds(SbBox2d self, double & xmin, double & ymin, double & xmax, double & ymax)\n"
		"SbBox2d_getBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint)\n"
		""},
	 { "SbBox2d_getMin", _wrap_SbBox2d_getMin, METH_VARARGS, "\n"
		"SbBox2d_getMin(SbBox2d self) -> SbVec2d\n"
		"SbBox2d_getMin(SbBox2d self) -> SbVec2d\n"
		""},
	 { "SbBox2d_getMax", _wrap_SbBox2d_getMax, METH_VARARGS, "\n"
		"SbBox2d_getMax(SbBox2d self) -> SbVec2d\n"
		"SbBox2d_getMax(SbBox2d self) -> SbVec2d\n"
		""},
	 { "SbBox2d_extendBy", _wrap_SbBox2d_extendBy, METH_VARARGS, "\n"
		"SbBox2d_extendBy(SbBox2d self, SbVec2d point)\n"
		"SbBox2d_extendBy(SbBox2d self, SbBox2d box)\n"
		""},
	 { "SbBox2d_makeEmpty", _wrap_SbBox2d_makeEmpty, METH_O, "SbBox2d_makeEmpty(SbBox2d self)"},
	 { "SbBox2d_isEmpty", _wrap_SbBox2d_isEmpty, METH_O, "SbBox2d_isEmpty(SbBox2d self) -> SbBool"},
	 { "SbBox2d_hasArea", _wrap_SbBox2d_hasArea, METH_O, "SbBox2d_hasArea(SbBox2d self) -> SbBool"},
	 { "SbBox2d_intersect", _wrap_SbBox2d_intersect, METH_VARARGS, "\n"
		"SbBox2d_intersect(SbBox2d self, SbVec2d point) -> SbBool\n"
		"SbBox2d_intersect(SbBox2d self, SbBox2d box) -> SbBool\n"
		""},
	 { "SbBox2d_getClosestPoint", _wrap_SbBox2d_getClosestPoint, METH_VARARGS, "SbBox2d_getClosestPoint(SbBox2d self, SbVec2d p) -> SbVec2d"},
	 { "SbBox2d_findIntersection", _wrap_SbBox2d_findIntersection, METH_VARARGS, "SbBox2d_findIntersection(SbBox2d self, SbVec2d a, SbVec2d b, SbVec2d ia, SbVec2d ib) -> SbBool"},
	 { "SbBox2d_getCenter", _wrap_SbBox2d_getCenter, METH_O, "SbBox2d_getCenter(SbBox2d self) -> SbVec2d"},
	 { "SbBox2d_getOrigin", _wrap_SbBox2d_getOrigin, METH_VARARGS, "SbBox2d_getOrigin(SbBox2d self, double & originX, double & originY)"},
	 { "SbBox2d_getSize", _wrap_SbBox2d_getSize, METH_VARARGS, "\n"
		"SbBox2d_getSize(SbBox2d self, double & sizeX, double & sizeY)\n"
		"SbBox2d_getSize(SbBox2d self) -> SbVec2d\n"
		""},
	 { "SbBox2d_getAspectRatio", _wrap_SbBox2d_getAspectRatio, METH_O, "SbBox2d_getAspectRatio(SbBox2d self) -> double"},
	 { "SbBox2d___eq__", _wrap_SbBox2d___eq__, METH_VARARGS, "SbBox2d___eq__(SbBox2d self, SbBox2d u) -> int"},
	 { "SbBox2d___ne__", _wrap_SbBox2d___ne__, METH_VARARGS, "SbBox2d___ne__(SbBox2d self, SbBox2d u) -> int"},
	 { "SbBox2d_setValue", _wrap_SbBox2d_setValue, METH_VARARGS, "SbBox2d_setValue(SbBox2d self, SbBox2d u) -> SbBox2d"},
	 { "delete_SbBox2d", _wrap_delete_SbBox2d, METH_O, "delete_SbBox2d(SbBox2d self)"},
	 { "SbBox2d_swigregister", SbBox2d_swigregister, METH_O, NULL},
	 { "SbBox2d_swiginit", SbBox2d_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox2d", _wrap_new_SoSFBox2d, METH_NOARGS, "new_SoSFBox2d() -> SoSFBox2d"},
	 { "delete_SoSFBox2d", _wrap_delete_SoSFBox2d, METH_O, "delete_SoSFBox2d(SoSFBox2d self)"},
	 { "SoSFBox2d_createInstance", _wrap_SoSFBox2d_createInstance, METH_NOARGS, "SoSFBox2d_createInstance() -> void *"},
	 { "SoSFBox2d_getClassTypeId", _wrap_SoSFBox2d_getClassTypeId, METH_NOARGS, "SoSFBox2d_getClassTypeId() -> SoType"},
	 { "SoSFBox2d_getTypeId", _wrap_SoSFBox2d_getTypeId, METH_O, "SoSFBox2d_getTypeId(SoSFBox2d self) -> SoType"},
	 { "SoSFBox2d_copyFrom", _wrap_SoSFBox2d_copyFrom, METH_VARARGS, "SoSFBox2d_copyFrom(SoSFBox2d self, SoField field)"},
	 { "SoSFBox2d_isSame", _wrap_SoSFBox2d_isSame, METH_VARARGS, "SoSFBox2d_isSame(SoSFBox2d self, SoField field) -> SbBool"},
	 { "SoSFBox2d___eq__", _wrap_SoSFBox2d___eq__, METH_VARARGS, "SoSFBox2d___eq__(SoSFBox2d self, SoSFBox2d field) -> int"},
	 { "SoSFBox2d___ne__", _wrap_SoSFBox2d___ne__, METH_VARARGS, "SoSFBox2d___ne__(SoSFBox2d self, SoSFBox2d field) -> int"},
	 { "SoSFBox2d_initClass", _wrap_SoSFBox2d_initClass, METH_NOARGS, "SoSFBox2d_initClass()"},
	 { "SoSFBox2d_setValue", _wrap_SoSFBox2d_setValue, METH_VARARGS, "\n"
		"SoSFBox2d_setValue(SoSFBox2d self, SbBox2d newvalue)\n"
		"SoSFBox2d_setValue(SoSFBox2d self, double xmin, double ymin, double xmax, double ymax)\n"
		"SoSFBox2d_setValue(SoSFBox2d self, SbVec2d minvec, SbVec2d maxvec)\n"
		""},
	 { "SoSFBox2d_getValue", _wrap_SoSFBox2d_getValue, METH_VARARGS, "\n"
		"SoSFBox2d_getValue(SoSFBox2d self) -> SbBox2d\n"
		"SoSFBox2d_getValue(SoSFBox2d self, SbBox2d box)\n"
		""},
	 { "SoSFBox2d_swigregister", SoSFBox2d_swigregister, METH_O, NULL},
	 { "SoSFBox2d_swiginit", SoSFBox2d_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox3s", _wrap_new_SbBox3s, METH_VARARGS, "\n"
		"SbBox3s()\n"
		"SbBox3s(short xmin, short ymin, short zmin, short xmax, short ymax, short zmax)\n"
		"SbBox3s(SbVec3s minpoint, SbVec3s maxpoint)\n"
		"SbBox3s(SbBox3i32 box)\n"
		"SbBox3s(SbBox3f box)\n"
		"new_SbBox3s(SbBox3d box) -> SbBox3s\n"
		""},
	 { "SbBox3s_setBounds", _wrap_SbBox3s_setBounds, METH_VARARGS, "\n"
		"SbBox3s_setBounds(SbBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax) -> SbBox3s\n"
		"SbBox3s_setBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s\n"
		"SbBox3s_setBounds(SbBox3s self, SbBox3i32 box) -> SbBox3s\n"
		"SbBox3s_setBounds(SbBox3s self, SbBox3f box) -> SbBox3s\n"
		"SbBox3s_setBounds(SbBox3s self, SbBox3d box) -> SbBox3s\n"
		""},
	 { "SbBox3s_getBounds", _wrap_SbBox3s_getBounds, METH_VARARGS, "\n"
		"SbBox3s_getBounds(SbBox3s self, short & xmin, short & ymin, short & zmin, short & xmax, short & ymax, short & zmax)\n"
		"SbBox3s_getBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint)\n"
		""},
	 { "SbBox3s_getMin", _wrap_SbBox3s_getMin, METH_VARARGS, "\n"
		"SbBox3s_getMin(SbBox3s self) -> SbVec3s\n"
		"SbBox3s_getMin(SbBox3s self) -> SbVec3s\n"
		""},
	 { "SbBox3s_getMax", _wrap_SbBox3s_getMax, METH_VARARGS, "\n"
		"SbBox3s_getMax(SbBox3s self) -> SbVec3s\n"
		"SbBox3s_getMax(SbBox3s self) -> SbVec3s\n"
		""},
	 { "SbBox3s_extendBy", _wrap_SbBox3s_extendBy, METH_VARARGS, "\n"
		"SbBox3s_extendBy(SbBox3s self, SbVec3s pt)\n"
		"SbBox3s_extendBy(SbBox3s self, SbBox3s box)\n"
		""},
	 { "SbBox3s_makeEmpty", _wrap_SbBox3s_makeEmpty, METH_O, "SbBox3s_makeEmpty(SbBox3s self)"},
	 { "SbBox3s_isEmpty", _wrap_SbBox3s_isEmpty, METH_O, "SbBox3s_isEmpty(SbBox3s self) -> SbBool"},
	 { "SbBox3s_hasVolume", _wrap_SbBox3s_hasVolume, METH_O, "SbBox3s_hasVolume(SbBox3s self) -> SbBool"},
	 { "SbBox3s_getVolume", _wrap_SbBox3s_getVolume, METH_O, "SbBox3s_getVolume(SbBox3s self) -> int"},
	 { "SbBox3s_intersect", _wrap_SbBox3s_intersect, METH_VARARGS, "\n"
		"SbBox3s_intersect(SbBox3s self, SbVec3s pt) -> SbBool\n"
		"SbBox3s_intersect(SbBox3s self, SbBox3s box) -> SbBool\n"
		""},
	 { "SbBox3s_getClosestPoint", _wrap_SbBox3s_getClosestPoint, METH_VARARGS, "SbBox3s_getClosestPoint(SbBox3s self, SbVec3f pt) -> SbVec3f"},
	 { "SbBox3s_getCenter", _wrap_SbBox3s_getCenter, METH_O, "SbBox3s_getCenter(SbBox3s self) -> SbVec3f"},
	 { "SbBox3s_getOrigin", _wrap_SbBox3s_getOrigin, METH_VARARGS, "SbBox3s_getOrigin(SbBox3s self, short & originX, short & originY, short & originZ)"},
	 { "SbBox3s_getSize", _wrap_SbBox3s_getSize, METH_VARARGS, "\n"
		"SbBox3s_getSize(SbBox3s self, short & sizeX, short & sizeY, short & sizeZ)\n"
		"SbBox3s_getSize(SbBox3s self) -> SbVec3s\n"
		""},
	 { "SbBox3s___eq__", _wrap_SbBox3s___eq__, METH_VARARGS, "SbBox3s___eq__(SbBox3s self, SbBox3s u) -> int"},
	 { "SbBox3s___ne__", _wrap_SbBox3s___ne__, METH_VARARGS, "SbBox3s___ne__(SbBox3s self, SbBox3s u) -> int"},
	 { "delete_SbBox3s", _wrap_delete_SbBox3s, METH_O, "delete_SbBox3s(SbBox3s self)"},
	 { "SbBox3s_swigregister", SbBox3s_swigregister, METH_O, NULL},
	 { "SbBox3s_swiginit", SbBox3s_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox3s", _wrap_new_SoSFBox3s, METH_NOARGS, "new_SoSFBox3s() -> SoSFBox3s"},
	 { "delete_SoSFBox3s", _wrap_delete_SoSFBox3s, METH_O, "delete_SoSFBox3s(SoSFBox3s self)"},
	 { "SoSFBox3s_createInstance", _wrap_SoSFBox3s_createInstance, METH_NOARGS, "SoSFBox3s_createInstance() -> void *"},
	 { "SoSFBox3s_getClassTypeId", _wrap_SoSFBox3s_getClassTypeId, METH_NOARGS, "SoSFBox3s_getClassTypeId() -> SoType"},
	 { "SoSFBox3s_getTypeId", _wrap_SoSFBox3s_getTypeId, METH_O, "SoSFBox3s_getTypeId(SoSFBox3s self) -> SoType"},
	 { "SoSFBox3s_copyFrom", _wrap_SoSFBox3s_copyFrom, METH_VARARGS, "SoSFBox3s_copyFrom(SoSFBox3s self, SoField field)"},
	 { "SoSFBox3s_isSame", _wrap_SoSFBox3s_isSame, METH_VARARGS, "SoSFBox3s_isSame(SoSFBox3s self, SoField field) -> SbBool"},
	 { "SoSFBox3s___eq__", _wrap_SoSFBox3s___eq__, METH_VARARGS, "SoSFBox3s___eq__(SoSFBox3s self, SoSFBox3s field) -> int"},
	 { "SoSFBox3s___ne__", _wrap_SoSFBox3s___ne__, METH_VARARGS, "SoSFBox3s___ne__(SoSFBox3s self, SoSFBox3s field) -> int"},
	 { "SoSFBox3s_initClass", _wrap_SoSFBox3s_initClass, METH_NOARGS, "SoSFBox3s_initClass()"},
	 { "SoSFBox3s_setValue", _wrap_SoSFBox3s_setValue, METH_VARARGS, "\n"
		"SoSFBox3s_setValue(SoSFBox3s self, SbBox3s newvalue)\n"
		"SoSFBox3s_setValue(SoSFBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax)\n"
		"SoSFBox3s_setValue(SoSFBox3s self, SbVec3s minvec, SbVec3s maxvec)\n"
		""},
	 { "SoSFBox3s_getValue", _wrap_SoSFBox3s_getValue, METH_VARARGS, "\n"
		"SoSFBox3s_getValue(SoSFBox3s self) -> SbBox3s\n"
		"SoSFBox3s_getValue(SoSFBox3s self, SbBox3s box)\n"
		""},
	 { "SoSFBox3s_swigregister", SoSFBox3s_swigregister, METH_O, NULL},
	 { "SoSFBox3s_swiginit", SoSFBox3s_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec3i32", _wrap_new_SbVec3i32, METH_VARARGS, "\n"
		"SbVec3i32()\n"
		"SbVec3i32(int32_t const [3] v)\n"
		"SbVec3i32(int32_t x, int32_t y, int32_t z)\n"
		"SbVec3i32(SbVec3ui32 const & v)\n"
		"SbVec3i32(SbVec3b v)\n"
		"SbVec3i32(SbVec3s v)\n"
		"SbVec3i32(SbVec3f v)\n"
		"new_SbVec3i32(SbVec3d v) -> SbVec3i32\n"
		""},
	 { "SbVec3i32_setValue", _wrap_SbVec3i32_setValue, METH_VARARGS, "\n"
		"SbVec3i32_setValue(SbVec3i32 self, int32_t const [3] v) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, int32_t x, int32_t y, int32_t z) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, SbVec3ui32 const & v) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, SbVec3b v) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, SbVec3s v) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, SbVec3f v) -> SbVec3i32\n"
		"SbVec3i32_setValue(SbVec3i32 self, SbVec3d v) -> SbVec3i32\n"
		""},
	 { "SbVec3i32_getValue", _wrap_SbVec3i32_getValue, METH_VARARGS, "\n"
		"SbVec3i32_getValue(SbVec3i32 self) -> int32_t const\n"
		"SbVec3i32_getValue(SbVec3i32 self, int32_t & x, int32_t & y, int32_t & z)\n"
		""},
	 { "SbVec3i32_dot", _wrap_SbVec3i32_dot, METH_VARARGS, "SbVec3i32_dot(SbVec3i32 self, SbVec3i32 v) -> int32_t"},
	 { "SbVec3i32_negate", _wrap_SbVec3i32_negate, METH_O, "SbVec3i32_negate(SbVec3i32 self)"},
	 { "SbVec3i32___imul__", _wrap_SbVec3i32___imul__, METH_VARARGS, "\n"
		"SbVec3i32___imul__(SbVec3i32 self, int d) -> SbVec3i32\n"
		"SbVec3i32___imul__(SbVec3i32 self, double d) -> SbVec3i32\n"
		""},
	 { "SbVec3i32___itruediv__", _wrap_SbVec3i32___itruediv__, METH_VARARGS, "\n"
		"SbVec3i32___itruediv__(SbVec3i32 self, int d) -> SbVec3i32\n"
		"SbVec3i32___itruediv__(SbVec3i32 self, double d) -> SbVec3i32\n"
		""},
	 { "SbVec3i32___iadd__", _wrap_SbVec3i32___iadd__, METH_VARARGS, "SbVec3i32___iadd__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"},
	 { "SbVec3i32___isub__", _wrap_SbVec3i32___isub__, METH_VARARGS, "SbVec3i32___isub__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"},
	 { "SbVec3i32___neg__", _wrap_SbVec3i32___neg__, METH_O, "SbVec3i32___neg__(SbVec3i32 self) -> SbVec3i32"},
	 { "delete_SbVec3i32", _wrap_delete_SbVec3i32, METH_O, "delete_SbVec3i32(SbVec3i32 self)"},
	 { "SbVec3i32_swigregister", SbVec3i32_swigregister, METH_O, NULL},
	 { "SbVec3i32_swiginit", SbVec3i32_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox3i32", _wrap_new_SbBox3i32, METH_VARARGS, "\n"
		"SbBox3i32()\n"
		"SbBox3i32(int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax)\n"
		"SbBox3i32(SbVec3i32 minpoint, SbVec3i32 maxpoint)\n"
		"SbBox3i32(SbBox3s box)\n"
		"SbBox3i32(SbBox3f box)\n"
		"new_SbBox3i32(SbBox3d box) -> SbBox3i32\n"
		""},
	 { "SbBox3i32_setBounds", _wrap_SbBox3i32_setBounds, METH_VARARGS, "\n"
		"SbBox3i32_setBounds(SbBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax) -> SbBox3i32\n"
		"SbBox3i32_setBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32\n"
		"SbBox3i32_setBounds(SbBox3i32 self, SbBox3s box) -> SbBox3i32\n"
		"SbBox3i32_setBounds(SbBox3i32 self, SbBox3f box) -> SbBox3i32\n"
		"SbBox3i32_setBounds(SbBox3i32 self, SbBox3d box) -> SbBox3i32\n"
		""},
	 { "SbBox3i32_getBounds", _wrap_SbBox3i32_getBounds, METH_VARARGS, "\n"
		"SbBox3i32_getBounds(SbBox3i32 self, int32_t & xmin, int32_t & ymin, int32_t & zmin, int32_t & xmax, int32_t & ymax, int32_t & zmax)\n"
		"SbBox3i32_getBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint)\n"
		""},
	 { "SbBox3i32_getMin", _wrap_SbBox3i32_getMin, METH_VARARGS, "\n"
		"SbBox3i32_getMin(SbBox3i32 self) -> SbVec3i32\n"
		"SbBox3i32_getMin(SbBox3i32 self) -> SbVec3i32\n"
		""},
	 { "SbBox3i32_getMax", _wrap_SbBox3i32_getMax, METH_VARARGS, "\n"
		"SbBox3i32_getMax(SbBox3i32 self) -> SbVec3i32\n"
		"SbBox3i32_getMax(SbBox3i32 self) -> SbVec3i32\n"
		""},
	 { "SbBox3i32_extendBy", _wrap_SbBox3i32_extendBy, METH_VARARGS, "\n"
		"SbBox3i32_extendBy(SbBox3i32 self, SbVec3i32 point)\n"
		"SbBox3i32_extendBy(SbBox3i32 self, SbBox3i32 box)\n"
		"SbBox3i32_extendBy(SbBox3i32 self, SbVec3f point)\n"
		""},
	 { "SbBox3i32_transform", _wrap_SbBox3i32_transform, METH_VARARGS, "SbBox3i32_transform(SbBox3i32 self, SbMatrix m)"},
	 { "SbBox3i32_makeEmpty", _wrap_SbBox3i32_makeEmpty, METH_O, "SbBox3i32_makeEmpty(SbBox3i32 self)"},
	 { "SbBox3i32_isEmpty", _wrap_SbBox3i32_isEmpty, METH_O, "SbBox3i32_isEmpty(SbBox3i32 self) -> SbBool"},
	 { "SbBox3i32_hasVolume", _wrap_SbBox3i32_hasVolume, METH_O, "SbBox3i32_hasVolume(SbBox3i32 self) -> SbBool"},
	 { "SbBox3i32_getVolume", _wrap_SbBox3i32_getVolume, METH_O, "SbBox3i32_getVolume(SbBox3i32 self) -> float"},
	 { "SbBox3i32_intersect", _wrap_SbBox3i32_intersect, METH_VARARGS, "\n"
		"SbBox3i32_intersect(SbBox3i32 self, SbVec3i32 point) -> SbBool\n"
		"SbBox3i32_intersect(SbBox3i32 self, SbBox3i32 box) -> SbBool\n"
		"SbBox3i32_intersect(SbBox3i32 self, SbVec3f point) -> SbBool\n"
		""},
	 { "SbBox3i32_outside", _wrap_SbBox3i32_outside, METH_VARARGS, "SbBox3i32_outside(SbBox3i32 self, SbMatrix mvp, int & cullBits) -> SbBool"},
	 { "SbBox3i32_getClosestPoint", _wrap_SbBox3i32_getClosestPoint, METH_VARARGS, "SbBox3i32_getClosestPoint(SbBox3i32 self, SbVec3f point) -> SbVec3f"},
	 { "SbBox3i32_getCenter", _wrap_SbBox3i32_getCenter, METH_O, "SbBox3i32_getCenter(SbBox3i32 self) -> SbVec3f"},
	 { "SbBox3i32_getOrigin", _wrap_SbBox3i32_getOrigin, METH_VARARGS, "SbBox3i32_getOrigin(SbBox3i32 self, int32_t & originX, int32_t & originY, int32_t & originZ)"},
	 { "SbBox3i32_getSize", _wrap_SbBox3i32_getSize, METH_VARARGS, "\n"
		"SbBox3i32_getSize(SbBox3i32 self, int32_t & sizeX, int32_t & sizeY, int32_t & sizeZ)\n"
		"SbBox3i32_getSize(SbBox3i32 self) -> SbVec3i32\n"
		""},
	 { "SbBox3i32_getSpan", _wrap_SbBox3i32_getSpan, METH_VARARGS, "SbBox3i32_getSpan(SbBox3i32 self, SbVec3f direction, float & dmin, float & dmax)"},
	 { "delete_SbBox3i32", _wrap_delete_SbBox3i32, METH_O, "delete_SbBox3i32(SbBox3i32 self)"},
	 { "SbBox3i32_swigregister", SbBox3i32_swigregister, METH_O, NULL},
	 { "SbBox3i32_swiginit", SbBox3i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox3i32", _wrap_new_SoSFBox3i32, METH_NOARGS, "new_SoSFBox3i32() -> SoSFBox3i32"},
	 { "delete_SoSFBox3i32", _wrap_delete_SoSFBox3i32, METH_O, "delete_SoSFBox3i32(SoSFBox3i32 self)"},
	 { "SoSFBox3i32_createInstance", _wrap_SoSFBox3i32_createInstance, METH_NOARGS, "SoSFBox3i32_createInstance() -> void *"},
	 { "SoSFBox3i32_getClassTypeId", _wrap_SoSFBox3i32_getClassTypeId, METH_NOARGS, "SoSFBox3i32_getClassTypeId() -> SoType"},
	 { "SoSFBox3i32_getTypeId", _wrap_SoSFBox3i32_getTypeId, METH_O, "SoSFBox3i32_getTypeId(SoSFBox3i32 self) -> SoType"},
	 { "SoSFBox3i32_copyFrom", _wrap_SoSFBox3i32_copyFrom, METH_VARARGS, "SoSFBox3i32_copyFrom(SoSFBox3i32 self, SoField field)"},
	 { "SoSFBox3i32_isSame", _wrap_SoSFBox3i32_isSame, METH_VARARGS, "SoSFBox3i32_isSame(SoSFBox3i32 self, SoField field) -> SbBool"},
	 { "SoSFBox3i32___eq__", _wrap_SoSFBox3i32___eq__, METH_VARARGS, "SoSFBox3i32___eq__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"},
	 { "SoSFBox3i32___ne__", _wrap_SoSFBox3i32___ne__, METH_VARARGS, "SoSFBox3i32___ne__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"},
	 { "SoSFBox3i32_initClass", _wrap_SoSFBox3i32_initClass, METH_NOARGS, "SoSFBox3i32_initClass()"},
	 { "SoSFBox3i32_setValue", _wrap_SoSFBox3i32_setValue, METH_VARARGS, "\n"
		"SoSFBox3i32_setValue(SoSFBox3i32 self, SbBox3i32 newvalue)\n"
		"SoSFBox3i32_setValue(SoSFBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax)\n"
		"SoSFBox3i32_setValue(SoSFBox3i32 self, SbVec3i32 minvec, SbVec3i32 maxvec)\n"
		""},
	 { "SoSFBox3i32_getValue", _wrap_SoSFBox3i32_getValue, METH_VARARGS, "\n"
		"SoSFBox3i32_getValue(SoSFBox3i32 self) -> SbBox3i32\n"
		"SoSFBox3i32_getValue(SoSFBox3i32 self, SbBox3i32 box)\n"
		""},
	 { "SoSFBox3i32_swigregister", SoSFBox3i32_swigregister, METH_O, NULL},
	 { "SoSFBox3i32_swiginit", SoSFBox3i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox3f", _wrap_new_SoSFBox3f, METH_NOARGS, "new_SoSFBox3f() -> SoSFBox3f"},
	 { "delete_SoSFBox3f", _wrap_delete_SoSFBox3f, METH_O, "delete_SoSFBox3f(SoSFBox3f self)"},
	 { "SoSFBox3f_createInstance", _wrap_SoSFBox3f_createInstance, METH_NOARGS, "SoSFBox3f_createInstance() -> void *"},
	 { "SoSFBox3f_getClassTypeId", _wrap_SoSFBox3f_getClassTypeId, METH_NOARGS, "SoSFBox3f_getClassTypeId() -> SoType"},
	 { "SoSFBox3f_getTypeId", _wrap_SoSFBox3f_getTypeId, METH_O, "SoSFBox3f_getTypeId(SoSFBox3f self) -> SoType"},
	 { "SoSFBox3f_copyFrom", _wrap_SoSFBox3f_copyFrom, METH_VARARGS, "SoSFBox3f_copyFrom(SoSFBox3f self, SoField field)"},
	 { "SoSFBox3f_isSame", _wrap_SoSFBox3f_isSame, METH_VARARGS, "SoSFBox3f_isSame(SoSFBox3f self, SoField field) -> SbBool"},
	 { "SoSFBox3f___eq__", _wrap_SoSFBox3f___eq__, METH_VARARGS, "SoSFBox3f___eq__(SoSFBox3f self, SoSFBox3f field) -> int"},
	 { "SoSFBox3f___ne__", _wrap_SoSFBox3f___ne__, METH_VARARGS, "SoSFBox3f___ne__(SoSFBox3f self, SoSFBox3f field) -> int"},
	 { "SoSFBox3f_initClass", _wrap_SoSFBox3f_initClass, METH_NOARGS, "SoSFBox3f_initClass()"},
	 { "SoSFBox3f_setValue", _wrap_SoSFBox3f_setValue, METH_VARARGS, "\n"
		"SoSFBox3f_setValue(SoSFBox3f self, SbBox3f newvalue)\n"
		"SoSFBox3f_setValue(SoSFBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax)\n"
		"SoSFBox3f_setValue(SoSFBox3f self, SbVec3f minvec, SbVec3f maxvec)\n"
		""},
	 { "SoSFBox3f_getValue", _wrap_SoSFBox3f_getValue, METH_VARARGS, "\n"
		"SoSFBox3f_getValue(SoSFBox3f self) -> SbBox3f\n"
		"SoSFBox3f_getValue(SoSFBox3f self, SbBox3f box)\n"
		""},
	 { "SoSFBox3f_swigregister", SoSFBox3f_swigregister, METH_O, NULL},
	 { "SoSFBox3f_swiginit", SoSFBox3f_swiginit, METH_VARARGS, NULL},
	 { "new_SbBox3d", _wrap_new_SbBox3d, METH_VARARGS, "\n"
		"SbBox3d()\n"
		"SbBox3d(double xmin, double ymin, double zmin, double xmax, double ymax, double zmax)\n"
		"SbBox3d(SbVec3d minpoint, SbVec3d maxpoint)\n"
		"SbBox3d(SbBox3f box)\n"
		"SbBox3d(SbBox3s box)\n"
		"new_SbBox3d(SbBox3i32 box) -> SbBox3d\n"
		""},
	 { "SbBox3d_setBounds", _wrap_SbBox3d_setBounds, METH_VARARGS, "\n"
		"SbBox3d_setBounds(SbBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax) -> SbBox3d\n"
		"SbBox3d_setBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d\n"
		"SbBox3d_setBounds(SbBox3d self, SbBox3f box) -> SbBox3d\n"
		"SbBox3d_setBounds(SbBox3d self, SbBox3s box) -> SbBox3d\n"
		"SbBox3d_setBounds(SbBox3d self, SbBox3i32 box) -> SbBox3d\n"
		""},
	 { "SbBox3d_getBounds", _wrap_SbBox3d_getBounds, METH_VARARGS, "\n"
		"SbBox3d_getBounds(SbBox3d self, double & xmin, double & ymin, double & zmin, double & xmax, double & ymax, double & zmax)\n"
		"SbBox3d_getBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint)\n"
		""},
	 { "SbBox3d_getMin", _wrap_SbBox3d_getMin, METH_VARARGS, "\n"
		"SbBox3d_getMin(SbBox3d self) -> SbVec3d\n"
		"SbBox3d_getMin(SbBox3d self) -> SbVec3d\n"
		""},
	 { "SbBox3d_getMax", _wrap_SbBox3d_getMax, METH_VARARGS, "\n"
		"SbBox3d_getMax(SbBox3d self) -> SbVec3d\n"
		"SbBox3d_getMax(SbBox3d self) -> SbVec3d\n"
		""},
	 { "SbBox3d_extendBy", _wrap_SbBox3d_extendBy, METH_VARARGS, "\n"
		"SbBox3d_extendBy(SbBox3d self, SbVec3d pt)\n"
		"SbBox3d_extendBy(SbBox3d self, SbBox3d box)\n"
		""},
	 { "SbBox3d_transform", _wrap_SbBox3d_transform, METH_VARARGS, "SbBox3d_transform(SbBox3d self, SbDPMatrix matrix)"},
	 { "SbBox3d_makeEmpty", _wrap_SbBox3d_makeEmpty, METH_O, "SbBox3d_makeEmpty(SbBox3d self)"},
	 { "SbBox3d_isEmpty", _wrap_SbBox3d_isEmpty, METH_O, "SbBox3d_isEmpty(SbBox3d self) -> SbBool"},
	 { "SbBox3d_hasVolume", _wrap_SbBox3d_hasVolume, METH_O, "SbBox3d_hasVolume(SbBox3d self) -> SbBool"},
	 { "SbBox3d_getVolume", _wrap_SbBox3d_getVolume, METH_O, "SbBox3d_getVolume(SbBox3d self) -> double"},
	 { "SbBox3d_intersect", _wrap_SbBox3d_intersect, METH_VARARGS, "\n"
		"SbBox3d_intersect(SbBox3d self, SbVec3d point) -> SbBool\n"
		"SbBox3d_intersect(SbBox3d self, SbBox3d box) -> SbBool\n"
		""},
	 { "SbBox3d_getClosestPoint", _wrap_SbBox3d_getClosestPoint, METH_VARARGS, "SbBox3d_getClosestPoint(SbBox3d self, SbVec3d point) -> SbVec3d"},
	 { "SbBox3d_outside", _wrap_SbBox3d_outside, METH_VARARGS, "SbBox3d_outside(SbBox3d self, SbDPMatrix mvp, int & cullbits) -> SbBool"},
	 { "SbBox3d_getCenter", _wrap_SbBox3d_getCenter, METH_O, "SbBox3d_getCenter(SbBox3d self) -> SbVec3d"},
	 { "SbBox3d_getOrigin", _wrap_SbBox3d_getOrigin, METH_VARARGS, "SbBox3d_getOrigin(SbBox3d self, double & origoX, double & origoY, double & origoZ)"},
	 { "SbBox3d_getSize", _wrap_SbBox3d_getSize, METH_VARARGS, "\n"
		"SbBox3d_getSize(SbBox3d self, double & sizeX, double & sizeY, double & sizeZ)\n"
		"SbBox3d_getSize(SbBox3d self) -> SbVec3d\n"
		""},
	 { "SbBox3d_getSpan", _wrap_SbBox3d_getSpan, METH_VARARGS, "SbBox3d_getSpan(SbBox3d self, SbVec3d dir, double & dmin, double & dmax)"},
	 { "SbBox3d_output", _wrap_SbBox3d_output, METH_VARARGS, "SbBox3d_output(SbBox3d self, FILE * file)"},
	 { "delete_SbBox3d", _wrap_delete_SbBox3d, METH_O, "delete_SbBox3d(SbBox3d self)"},
	 { "SbBox3d_swigregister", SbBox3d_swigregister, METH_O, NULL},
	 { "SbBox3d_swiginit", SbBox3d_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFBox3d", _wrap_new_SoSFBox3d, METH_NOARGS, "new_SoSFBox3d() -> SoSFBox3d"},
	 { "delete_SoSFBox3d", _wrap_delete_SoSFBox3d, METH_O, "delete_SoSFBox3d(SoSFBox3d self)"},
	 { "SoSFBox3d_createInstance", _wrap_SoSFBox3d_createInstance, METH_NOARGS, "SoSFBox3d_createInstance() -> void *"},
	 { "SoSFBox3d_getClassTypeId", _wrap_SoSFBox3d_getClassTypeId, METH_NOARGS, "SoSFBox3d_getClassTypeId() -> SoType"},
	 { "SoSFBox3d_getTypeId", _wrap_SoSFBox3d_getTypeId, METH_O, "SoSFBox3d_getTypeId(SoSFBox3d self) -> SoType"},
	 { "SoSFBox3d_copyFrom", _wrap_SoSFBox3d_copyFrom, METH_VARARGS, "SoSFBox3d_copyFrom(SoSFBox3d self, SoField field)"},
	 { "SoSFBox3d_isSame", _wrap_SoSFBox3d_isSame, METH_VARARGS, "SoSFBox3d_isSame(SoSFBox3d self, SoField field) -> SbBool"},
	 { "SoSFBox3d___eq__", _wrap_SoSFBox3d___eq__, METH_VARARGS, "SoSFBox3d___eq__(SoSFBox3d self, SoSFBox3d field) -> int"},
	 { "SoSFBox3d___ne__", _wrap_SoSFBox3d___ne__, METH_VARARGS, "SoSFBox3d___ne__(SoSFBox3d self, SoSFBox3d field) -> int"},
	 { "SoSFBox3d_initClass", _wrap_SoSFBox3d_initClass, METH_NOARGS, "SoSFBox3d_initClass()"},
	 { "SoSFBox3d_setValue", _wrap_SoSFBox3d_setValue, METH_VARARGS, "\n"
		"SoSFBox3d_setValue(SoSFBox3d self, SbBox3d newvalue)\n"
		"SoSFBox3d_setValue(SoSFBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax)\n"
		"SoSFBox3d_setValue(SoSFBox3d self, SbVec3d minvec, SbVec3d maxvec)\n"
		""},
	 { "SoSFBox3d_getValue", _wrap_SoSFBox3d_getValue, METH_VARARGS, "\n"
		"SoSFBox3d_getValue(SoSFBox3d self) -> SbBox3d\n"
		"SoSFBox3d_getValue(SoSFBox3d self, SbBox3d box)\n"
		""},
	 { "SoSFBox3d_swigregister", SoSFBox3d_swigregister, METH_O, NULL},
	 { "SoSFBox3d_swiginit", SoSFBox3d_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFColorRGBA", _wrap_new_SoSFColorRGBA, METH_NOARGS, "new_SoSFColorRGBA() -> SoSFColorRGBA"},
	 { "delete_SoSFColorRGBA", _wrap_delete_SoSFColorRGBA, METH_O, "delete_SoSFColorRGBA(SoSFColorRGBA self)"},
	 { "SoSFColorRGBA_createInstance", _wrap_SoSFColorRGBA_createInstance, METH_NOARGS, "SoSFColorRGBA_createInstance() -> void *"},
	 { "SoSFColorRGBA_getClassTypeId", _wrap_SoSFColorRGBA_getClassTypeId, METH_NOARGS, "SoSFColorRGBA_getClassTypeId() -> SoType"},
	 { "SoSFColorRGBA_getTypeId", _wrap_SoSFColorRGBA_getTypeId, METH_O, "SoSFColorRGBA_getTypeId(SoSFColorRGBA self) -> SoType"},
	 { "SoSFColorRGBA_copyFrom", _wrap_SoSFColorRGBA_copyFrom, METH_VARARGS, "SoSFColorRGBA_copyFrom(SoSFColorRGBA self, SoField field)"},
	 { "SoSFColorRGBA_isSame", _wrap_SoSFColorRGBA_isSame, METH_VARARGS, "SoSFColorRGBA_isSame(SoSFColorRGBA self, SoField field) -> SbBool"},
	 { "SoSFColorRGBA_getValue", _wrap_SoSFColorRGBA_getValue, METH_O, "SoSFColorRGBA_getValue(SoSFColorRGBA self) -> SbColor4f"},
	 { "SoSFColorRGBA___eq__", _wrap_SoSFColorRGBA___eq__, METH_VARARGS, "SoSFColorRGBA___eq__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"},
	 { "SoSFColorRGBA___ne__", _wrap_SoSFColorRGBA___ne__, METH_VARARGS, "SoSFColorRGBA___ne__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"},
	 { "SoSFColorRGBA_initClass", _wrap_SoSFColorRGBA_initClass, METH_NOARGS, "SoSFColorRGBA_initClass()"},
	 { "SoSFColorRGBA_setValue", _wrap_SoSFColorRGBA_setValue, METH_VARARGS, "\n"
		"SoSFColorRGBA_setValue(SoSFColorRGBA self, SbColor4f newvalue)\n"
		"SoSFColorRGBA_setValue(SoSFColorRGBA self, SbVec4f vec)\n"
		"SoSFColorRGBA_setValue(SoSFColorRGBA self, float red, float green, float blue, float alpha)\n"
		"SoSFColorRGBA_setValue(SoSFColorRGBA self, float const [4] rgba)\n"
		""},
	 { "SoSFColorRGBA_setHSVValue", _wrap_SoSFColorRGBA_setHSVValue, METH_VARARGS, "\n"
		"SoSFColorRGBA_setHSVValue(SoSFColorRGBA self, float h, float s, float v, float a)\n"
		"SoSFColorRGBA_setHSVValue(SoSFColorRGBA self, float const [4] hsva)\n"
		""},
	 { "SoSFColorRGBA_swigregister", SoSFColorRGBA_swigregister, METH_O, NULL},
	 { "SoSFColorRGBA_swiginit", SoSFColorRGBA_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFDouble", _wrap_new_SoSFDouble, METH_NOARGS, "new_SoSFDouble() -> SoSFDouble"},
	 { "delete_SoSFDouble", _wrap_delete_SoSFDouble, METH_O, "delete_SoSFDouble(SoSFDouble self)"},
	 { "SoSFDouble_createInstance", _wrap_SoSFDouble_createInstance, METH_NOARGS, "SoSFDouble_createInstance() -> void *"},
	 { "SoSFDouble_getClassTypeId", _wrap_SoSFDouble_getClassTypeId, METH_NOARGS, "SoSFDouble_getClassTypeId() -> SoType"},
	 { "SoSFDouble_getTypeId", _wrap_SoSFDouble_getTypeId, METH_O, "SoSFDouble_getTypeId(SoSFDouble self) -> SoType"},
	 { "SoSFDouble_copyFrom", _wrap_SoSFDouble_copyFrom, METH_VARARGS, "SoSFDouble_copyFrom(SoSFDouble self, SoField field)"},
	 { "SoSFDouble_isSame", _wrap_SoSFDouble_isSame, METH_VARARGS, "SoSFDouble_isSame(SoSFDouble self, SoField field) -> SbBool"},
	 { "SoSFDouble_getValue", _wrap_SoSFDouble_getValue, METH_O, "SoSFDouble_getValue(SoSFDouble self) -> double"},
	 { "SoSFDouble_setValue", _wrap_SoSFDouble_setValue, METH_VARARGS, "SoSFDouble_setValue(SoSFDouble self, double newvalue)"},
	 { "SoSFDouble___eq__", _wrap_SoSFDouble___eq__, METH_VARARGS, "SoSFDouble___eq__(SoSFDouble self, SoSFDouble field) -> int"},
	 { "SoSFDouble___ne__", _wrap_SoSFDouble___ne__, METH_VARARGS, "SoSFDouble___ne__(SoSFDouble self, SoSFDouble field) -> int"},
	 { "SoSFDouble_initClass", _wrap_SoSFDouble_initClass, METH_NOARGS, "SoSFDouble_initClass()"},
	 { "SoSFDouble_swigregister", SoSFDouble_swigregister, METH_O, NULL},
	 { "SoSFDouble_swiginit", SoSFDouble_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFEngine", _wrap_new_SoSFEngine, METH_NOARGS, "new_SoSFEngine() -> SoSFEngine"},
	 { "delete_SoSFEngine", _wrap_delete_SoSFEngine, METH_O, "delete_SoSFEngine(SoSFEngine self)"},
	 { "SoSFEngine_createInstance", _wrap_SoSFEngine_createInstance, METH_NOARGS, "SoSFEngine_createInstance() -> void *"},
	 { "SoSFEngine_getClassTypeId", _wrap_SoSFEngine_getClassTypeId, METH_NOARGS, "SoSFEngine_getClassTypeId() -> SoType"},
	 { "SoSFEngine_getTypeId", _wrap_SoSFEngine_getTypeId, METH_O, "SoSFEngine_getTypeId(SoSFEngine self) -> SoType"},
	 { "SoSFEngine_copyFrom", _wrap_SoSFEngine_copyFrom, METH_VARARGS, "SoSFEngine_copyFrom(SoSFEngine self, SoField field)"},
	 { "SoSFEngine_isSame", _wrap_SoSFEngine_isSame, METH_VARARGS, "SoSFEngine_isSame(SoSFEngine self, SoField field) -> SbBool"},
	 { "SoSFEngine_getValue", _wrap_SoSFEngine_getValue, METH_O, "SoSFEngine_getValue(SoSFEngine self) -> SoEngine"},
	 { "SoSFEngine___eq__", _wrap_SoSFEngine___eq__, METH_VARARGS, "SoSFEngine___eq__(SoSFEngine self, SoSFEngine field) -> int"},
	 { "SoSFEngine___ne__", _wrap_SoSFEngine___ne__, METH_VARARGS, "SoSFEngine___ne__(SoSFEngine self, SoSFEngine field) -> int"},
	 { "SoSFEngine_initClass", _wrap_SoSFEngine_initClass, METH_NOARGS, "SoSFEngine_initClass()"},
	 { "SoSFEngine_fixCopy", _wrap_SoSFEngine_fixCopy, METH_VARARGS, "SoSFEngine_fixCopy(SoSFEngine self, SbBool copyconnections)"},
	 { "SoSFEngine_referencesCopy", _wrap_SoSFEngine_referencesCopy, METH_O, "SoSFEngine_referencesCopy(SoSFEngine self) -> SbBool"},
	 { "SoSFEngine_setValue", _wrap_SoSFEngine_setValue, METH_VARARGS, "\n"
		"SoSFEngine_setValue(SoSFEngine self, SoEngine newvalue)\n"
		"SoSFEngine_setValue(SoSFEngine self, SoSFEngine other)\n"
		""},
	 { "SoSFEngine_swigregister", SoSFEngine_swigregister, METH_O, NULL},
	 { "SoSFEngine_swiginit", SoSFEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFImage3", _wrap_new_SoSFImage3, METH_NOARGS, "new_SoSFImage3() -> SoSFImage3"},
	 { "delete_SoSFImage3", _wrap_delete_SoSFImage3, METH_O, "delete_SoSFImage3(SoSFImage3 self)"},
	 { "SoSFImage3_createInstance", _wrap_SoSFImage3_createInstance, METH_NOARGS, "SoSFImage3_createInstance() -> void *"},
	 { "SoSFImage3_getClassTypeId", _wrap_SoSFImage3_getClassTypeId, METH_NOARGS, "SoSFImage3_getClassTypeId() -> SoType"},
	 { "SoSFImage3_getTypeId", _wrap_SoSFImage3_getTypeId, METH_O, "SoSFImage3_getTypeId(SoSFImage3 self) -> SoType"},
	 { "SoSFImage3_copyFrom", _wrap_SoSFImage3_copyFrom, METH_VARARGS, "SoSFImage3_copyFrom(SoSFImage3 self, SoField field)"},
	 { "SoSFImage3_isSame", _wrap_SoSFImage3_isSame, METH_VARARGS, "SoSFImage3_isSame(SoSFImage3 self, SoField field) -> SbBool"},
	 { "SoSFImage3_initClass", _wrap_SoSFImage3_initClass, METH_NOARGS, "SoSFImage3_initClass()"},
	 { "SoSFImage3_getValue", _wrap_SoSFImage3_getValue, METH_O, "SoSFImage3_getValue(SoSFImage3 self) -> unsigned char const *"},
	 { "SoSFImage3___eq__", _wrap_SoSFImage3___eq__, METH_VARARGS, "SoSFImage3___eq__(SoSFImage3 self, SoSFImage3 field) -> int"},
	 { "SoSFImage3___ne__", _wrap_SoSFImage3___ne__, METH_VARARGS, "SoSFImage3___ne__(SoSFImage3 self, SoSFImage3 field) -> int"},
	 { "SoSFImage3_startEditing", _wrap_SoSFImage3_startEditing, METH_O, "SoSFImage3_startEditing(SoSFImage3 self) -> unsigned char *"},
	 { "SoSFImage3_finishEditing", _wrap_SoSFImage3_finishEditing, METH_O, "SoSFImage3_finishEditing(SoSFImage3 self)"},
	 { "SoSFImage3_setValue", _wrap_SoSFImage3_setValue, METH_VARARGS, "\n"
		"SoSFImage3_setValue(SoSFImage3 self, SbVec3s size, int const nc, unsigned char const * bytes)\n"
		"SoSFImage3_setValue(SoSFImage3 self, SbVec3s size, int const nc, PyObject * pixels)\n"
		"SoSFImage3_setValue(SoSFImage3 self, SoSFImage3 other)\n"
		""},
	 { "SoSFImage3_swigregister", SoSFImage3_swigregister, METH_O, NULL},
	 { "SoSFImage3_swiginit", SoSFImage3_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFMatrix", _wrap_new_SoSFMatrix, METH_NOARGS, "new_SoSFMatrix() -> SoSFMatrix"},
	 { "delete_SoSFMatrix", _wrap_delete_SoSFMatrix, METH_O, "delete_SoSFMatrix(SoSFMatrix self)"},
	 { "SoSFMatrix_createInstance", _wrap_SoSFMatrix_createInstance, METH_NOARGS, "SoSFMatrix_createInstance() -> void *"},
	 { "SoSFMatrix_getClassTypeId", _wrap_SoSFMatrix_getClassTypeId, METH_NOARGS, "SoSFMatrix_getClassTypeId() -> SoType"},
	 { "SoSFMatrix_getTypeId", _wrap_SoSFMatrix_getTypeId, METH_O, "SoSFMatrix_getTypeId(SoSFMatrix self) -> SoType"},
	 { "SoSFMatrix_copyFrom", _wrap_SoSFMatrix_copyFrom, METH_VARARGS, "SoSFMatrix_copyFrom(SoSFMatrix self, SoField field)"},
	 { "SoSFMatrix_isSame", _wrap_SoSFMatrix_isSame, METH_VARARGS, "SoSFMatrix_isSame(SoSFMatrix self, SoField field) -> SbBool"},
	 { "SoSFMatrix_getValue", _wrap_SoSFMatrix_getValue, METH_O, "SoSFMatrix_getValue(SoSFMatrix self) -> SbMatrix"},
	 { "SoSFMatrix___eq__", _wrap_SoSFMatrix___eq__, METH_VARARGS, "SoSFMatrix___eq__(SoSFMatrix self, SoSFMatrix field) -> int"},
	 { "SoSFMatrix___ne__", _wrap_SoSFMatrix___ne__, METH_VARARGS, "SoSFMatrix___ne__(SoSFMatrix self, SoSFMatrix field) -> int"},
	 { "SoSFMatrix_initClass", _wrap_SoSFMatrix_initClass, METH_NOARGS, "SoSFMatrix_initClass()"},
	 { "SoSFMatrix_setValue", _wrap_SoSFMatrix_setValue, METH_VARARGS, "\n"
		"SoSFMatrix_setValue(SoSFMatrix self, SbMatrix newvalue)\n"
		"SoSFMatrix_setValue(SoSFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)\n"
		"SoSFMatrix_setValue(SoSFMatrix self, SoSFMatrix other)\n"
		""},
	 { "SoSFMatrix_swigregister", SoSFMatrix_swigregister, METH_O, NULL},
	 { "SoSFMatrix_swiginit", SoSFMatrix_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFPlane", _wrap_new_SoSFPlane, METH_NOARGS, "new_SoSFPlane() -> SoSFPlane"},
	 { "delete_SoSFPlane", _wrap_delete_SoSFPlane, METH_O, "delete_SoSFPlane(SoSFPlane self)"},
	 { "SoSFPlane_createInstance", _wrap_SoSFPlane_createInstance, METH_NOARGS, "SoSFPlane_createInstance() -> void *"},
	 { "SoSFPlane_getClassTypeId", _wrap_SoSFPlane_getClassTypeId, METH_NOARGS, "SoSFPlane_getClassTypeId() -> SoType"},
	 { "SoSFPlane_getTypeId", _wrap_SoSFPlane_getTypeId, METH_O, "SoSFPlane_getTypeId(SoSFPlane self) -> SoType"},
	 { "SoSFPlane_copyFrom", _wrap_SoSFPlane_copyFrom, METH_VARARGS, "SoSFPlane_copyFrom(SoSFPlane self, SoField field)"},
	 { "SoSFPlane_isSame", _wrap_SoSFPlane_isSame, METH_VARARGS, "SoSFPlane_isSame(SoSFPlane self, SoField field) -> SbBool"},
	 { "SoSFPlane_getValue", _wrap_SoSFPlane_getValue, METH_O, "SoSFPlane_getValue(SoSFPlane self) -> SbPlane"},
	 { "SoSFPlane___eq__", _wrap_SoSFPlane___eq__, METH_VARARGS, "SoSFPlane___eq__(SoSFPlane self, SoSFPlane field) -> int"},
	 { "SoSFPlane___ne__", _wrap_SoSFPlane___ne__, METH_VARARGS, "SoSFPlane___ne__(SoSFPlane self, SoSFPlane field) -> int"},
	 { "SoSFPlane_initClass", _wrap_SoSFPlane_initClass, METH_NOARGS, "SoSFPlane_initClass()"},
	 { "SoSFPlane_setValue", _wrap_SoSFPlane_setValue, METH_VARARGS, "\n"
		"SoSFPlane_setValue(SoSFPlane self, SbPlane newvalue)\n"
		"SoSFPlane_setValue(SoSFPlane self, SoSFPlane other)\n"
		""},
	 { "SoSFPlane_swigregister", SoSFPlane_swigregister, METH_O, NULL},
	 { "SoSFPlane_swiginit", SoSFPlane_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFUInt32", _wrap_new_SoSFUInt32, METH_NOARGS, "new_SoSFUInt32() -> SoSFUInt32"},
	 { "delete_SoSFUInt32", _wrap_delete_SoSFUInt32, METH_O, "delete_SoSFUInt32(SoSFUInt32 self)"},
	 { "SoSFUInt32_createInstance", _wrap_SoSFUInt32_createInstance, METH_NOARGS, "SoSFUInt32_createInstance() -> void *"},
	 { "SoSFUInt32_getClassTypeId", _wrap_SoSFUInt32_getClassTypeId, METH_NOARGS, "SoSFUInt32_getClassTypeId() -> SoType"},
	 { "SoSFUInt32_getTypeId", _wrap_SoSFUInt32_getTypeId, METH_O, "SoSFUInt32_getTypeId(SoSFUInt32 self) -> SoType"},
	 { "SoSFUInt32_copyFrom", _wrap_SoSFUInt32_copyFrom, METH_VARARGS, "SoSFUInt32_copyFrom(SoSFUInt32 self, SoField field)"},
	 { "SoSFUInt32_isSame", _wrap_SoSFUInt32_isSame, METH_VARARGS, "SoSFUInt32_isSame(SoSFUInt32 self, SoField field) -> SbBool"},
	 { "SoSFUInt32_getValue", _wrap_SoSFUInt32_getValue, METH_O, "SoSFUInt32_getValue(SoSFUInt32 self) -> uint32_t"},
	 { "SoSFUInt32___eq__", _wrap_SoSFUInt32___eq__, METH_VARARGS, "SoSFUInt32___eq__(SoSFUInt32 self, SoSFUInt32 field) -> int"},
	 { "SoSFUInt32___ne__", _wrap_SoSFUInt32___ne__, METH_VARARGS, "SoSFUInt32___ne__(SoSFUInt32 self, SoSFUInt32 field) -> int"},
	 { "SoSFUInt32_initClass", _wrap_SoSFUInt32_initClass, METH_NOARGS, "SoSFUInt32_initClass()"},
	 { "SoSFUInt32_setValue", _wrap_SoSFUInt32_setValue, METH_VARARGS, "\n"
		"SoSFUInt32_setValue(SoSFUInt32 self, uint32_t newvalue)\n"
		"SoSFUInt32_setValue(SoSFUInt32 self, SoSFUInt32 other)\n"
		""},
	 { "SoSFUInt32_swigregister", SoSFUInt32_swigregister, METH_O, NULL},
	 { "SoSFUInt32_swiginit", SoSFUInt32_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec2b", _wrap_new_SbVec2b, METH_VARARGS, "\n"
		"SbVec2b()\n"
		"SbVec2b(int8_t const [2] v)\n"
		"SbVec2b(int8_t x, int8_t y)\n"
		"SbVec2b(SbVec2ub const & v)\n"
		"SbVec2b(SbVec2s v)\n"
		"SbVec2b(SbVec2i32 v)\n"
		"SbVec2b(SbVec2f v)\n"
		"new_SbVec2b(SbVec2d v) -> SbVec2b\n"
		""},
	 { "SbVec2b_setValue", _wrap_SbVec2b_setValue, METH_VARARGS, "\n"
		"SbVec2b_setValue(SbVec2b self, int8_t const [2] v) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, int8_t x, int8_t y) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, SbVec2ub const & v) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, SbVec2s v) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, SbVec2i32 v) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, SbVec2f v) -> SbVec2b\n"
		"SbVec2b_setValue(SbVec2b self, SbVec2d v) -> SbVec2b\n"
		""},
	 { "SbVec2b_getValue", _wrap_SbVec2b_getValue, METH_VARARGS, "\n"
		"SbVec2b_getValue(SbVec2b self) -> int8_t const\n"
		"SbVec2b_getValue(SbVec2b self, int8_t & x, int8_t & y)\n"
		""},
	 { "SbVec2b_dot", _wrap_SbVec2b_dot, METH_VARARGS, "SbVec2b_dot(SbVec2b self, SbVec2b v) -> int32_t"},
	 { "SbVec2b_negate", _wrap_SbVec2b_negate, METH_O, "SbVec2b_negate(SbVec2b self)"},
	 { "SbVec2b___imul__", _wrap_SbVec2b___imul__, METH_VARARGS, "\n"
		"SbVec2b___imul__(SbVec2b self, int d) -> SbVec2b\n"
		"SbVec2b___imul__(SbVec2b self, double d) -> SbVec2b\n"
		""},
	 { "SbVec2b___itruediv__", _wrap_SbVec2b___itruediv__, METH_VARARGS, "\n"
		"SbVec2b___itruediv__(SbVec2b self, int d) -> SbVec2b\n"
		"SbVec2b___itruediv__(SbVec2b self, double d) -> SbVec2b\n"
		""},
	 { "SbVec2b___iadd__", _wrap_SbVec2b___iadd__, METH_VARARGS, "SbVec2b___iadd__(SbVec2b self, SbVec2b v) -> SbVec2b"},
	 { "SbVec2b___isub__", _wrap_SbVec2b___isub__, METH_VARARGS, "SbVec2b___isub__(SbVec2b self, SbVec2b v) -> SbVec2b"},
	 { "SbVec2b___neg__", _wrap_SbVec2b___neg__, METH_O, "SbVec2b___neg__(SbVec2b self) -> SbVec2b"},
	 { "delete_SbVec2b", _wrap_delete_SbVec2b, METH_O, "delete_SbVec2b(SbVec2b self)"},
	 { "SbVec2b_swigregister", SbVec2b_swigregister, METH_O, NULL},
	 { "SbVec2b_swiginit", SbVec2b_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec2b", _wrap_new_SoSFVec2b, METH_NOARGS, "new_SoSFVec2b() -> SoSFVec2b"},
	 { "delete_SoSFVec2b", _wrap_delete_SoSFVec2b, METH_O, "delete_SoSFVec2b(SoSFVec2b self)"},
	 { "SoSFVec2b_createInstance", _wrap_SoSFVec2b_createInstance, METH_NOARGS, "SoSFVec2b_createInstance() -> void *"},
	 { "SoSFVec2b_getClassTypeId", _wrap_SoSFVec2b_getClassTypeId, METH_NOARGS, "SoSFVec2b_getClassTypeId() -> SoType"},
	 { "SoSFVec2b_getTypeId", _wrap_SoSFVec2b_getTypeId, METH_O, "SoSFVec2b_getTypeId(SoSFVec2b self) -> SoType"},
	 { "SoSFVec2b_copyFrom", _wrap_SoSFVec2b_copyFrom, METH_VARARGS, "SoSFVec2b_copyFrom(SoSFVec2b self, SoField field)"},
	 { "SoSFVec2b_isSame", _wrap_SoSFVec2b_isSame, METH_VARARGS, "SoSFVec2b_isSame(SoSFVec2b self, SoField field) -> SbBool"},
	 { "SoSFVec2b_getValue", _wrap_SoSFVec2b_getValue, METH_O, "SoSFVec2b_getValue(SoSFVec2b self) -> SbVec2b"},
	 { "SoSFVec2b___eq__", _wrap_SoSFVec2b___eq__, METH_VARARGS, "SoSFVec2b___eq__(SoSFVec2b self, SoSFVec2b field) -> int"},
	 { "SoSFVec2b___ne__", _wrap_SoSFVec2b___ne__, METH_VARARGS, "SoSFVec2b___ne__(SoSFVec2b self, SoSFVec2b field) -> int"},
	 { "SoSFVec2b_initClass", _wrap_SoSFVec2b_initClass, METH_NOARGS, "SoSFVec2b_initClass()"},
	 { "SoSFVec2b_setValue", _wrap_SoSFVec2b_setValue, METH_VARARGS, "\n"
		"SoSFVec2b_setValue(SoSFVec2b self, SbVec2b newvalue)\n"
		"SoSFVec2b_setValue(SoSFVec2b self, int8_t x, int8_t y)\n"
		"SoSFVec2b_setValue(SoSFVec2b self, int8_t const [2] xy)\n"
		""},
	 { "SoSFVec2b_swigregister", SoSFVec2b_swigregister, METH_O, NULL},
	 { "SoSFVec2b_swiginit", SoSFVec2b_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec2s", _wrap_new_SoSFVec2s, METH_NOARGS, "new_SoSFVec2s() -> SoSFVec2s"},
	 { "delete_SoSFVec2s", _wrap_delete_SoSFVec2s, METH_O, "delete_SoSFVec2s(SoSFVec2s self)"},
	 { "SoSFVec2s_createInstance", _wrap_SoSFVec2s_createInstance, METH_NOARGS, "SoSFVec2s_createInstance() -> void *"},
	 { "SoSFVec2s_getClassTypeId", _wrap_SoSFVec2s_getClassTypeId, METH_NOARGS, "SoSFVec2s_getClassTypeId() -> SoType"},
	 { "SoSFVec2s_getTypeId", _wrap_SoSFVec2s_getTypeId, METH_O, "SoSFVec2s_getTypeId(SoSFVec2s self) -> SoType"},
	 { "SoSFVec2s_copyFrom", _wrap_SoSFVec2s_copyFrom, METH_VARARGS, "SoSFVec2s_copyFrom(SoSFVec2s self, SoField field)"},
	 { "SoSFVec2s_isSame", _wrap_SoSFVec2s_isSame, METH_VARARGS, "SoSFVec2s_isSame(SoSFVec2s self, SoField field) -> SbBool"},
	 { "SoSFVec2s_getValue", _wrap_SoSFVec2s_getValue, METH_O, "SoSFVec2s_getValue(SoSFVec2s self) -> SbVec2s"},
	 { "SoSFVec2s___eq__", _wrap_SoSFVec2s___eq__, METH_VARARGS, "SoSFVec2s___eq__(SoSFVec2s self, SoSFVec2s field) -> int"},
	 { "SoSFVec2s___ne__", _wrap_SoSFVec2s___ne__, METH_VARARGS, "SoSFVec2s___ne__(SoSFVec2s self, SoSFVec2s field) -> int"},
	 { "SoSFVec2s_initClass", _wrap_SoSFVec2s_initClass, METH_NOARGS, "SoSFVec2s_initClass()"},
	 { "SoSFVec2s_setValue", _wrap_SoSFVec2s_setValue, METH_VARARGS, "\n"
		"SoSFVec2s_setValue(SoSFVec2s self, SbVec2s newvalue)\n"
		"SoSFVec2s_setValue(SoSFVec2s self, short x, short y)\n"
		"SoSFVec2s_setValue(SoSFVec2s self, short const [2] xy)\n"
		""},
	 { "SoSFVec2s_swigregister", SoSFVec2s_swigregister, METH_O, NULL},
	 { "SoSFVec2s_swiginit", SoSFVec2s_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec2i32", _wrap_new_SoSFVec2i32, METH_NOARGS, "new_SoSFVec2i32() -> SoSFVec2i32"},
	 { "delete_SoSFVec2i32", _wrap_delete_SoSFVec2i32, METH_O, "delete_SoSFVec2i32(SoSFVec2i32 self)"},
	 { "SoSFVec2i32_createInstance", _wrap_SoSFVec2i32_createInstance, METH_NOARGS, "SoSFVec2i32_createInstance() -> void *"},
	 { "SoSFVec2i32_getClassTypeId", _wrap_SoSFVec2i32_getClassTypeId, METH_NOARGS, "SoSFVec2i32_getClassTypeId() -> SoType"},
	 { "SoSFVec2i32_getTypeId", _wrap_SoSFVec2i32_getTypeId, METH_O, "SoSFVec2i32_getTypeId(SoSFVec2i32 self) -> SoType"},
	 { "SoSFVec2i32_copyFrom", _wrap_SoSFVec2i32_copyFrom, METH_VARARGS, "SoSFVec2i32_copyFrom(SoSFVec2i32 self, SoField field)"},
	 { "SoSFVec2i32_isSame", _wrap_SoSFVec2i32_isSame, METH_VARARGS, "SoSFVec2i32_isSame(SoSFVec2i32 self, SoField field) -> SbBool"},
	 { "SoSFVec2i32_getValue", _wrap_SoSFVec2i32_getValue, METH_O, "SoSFVec2i32_getValue(SoSFVec2i32 self) -> SbVec2i32"},
	 { "SoSFVec2i32___eq__", _wrap_SoSFVec2i32___eq__, METH_VARARGS, "SoSFVec2i32___eq__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"},
	 { "SoSFVec2i32___ne__", _wrap_SoSFVec2i32___ne__, METH_VARARGS, "SoSFVec2i32___ne__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"},
	 { "SoSFVec2i32_initClass", _wrap_SoSFVec2i32_initClass, METH_NOARGS, "SoSFVec2i32_initClass()"},
	 { "SoSFVec2i32_setValue", _wrap_SoSFVec2i32_setValue, METH_VARARGS, "\n"
		"SoSFVec2i32_setValue(SoSFVec2i32 self, SbVec2i32 newvalue)\n"
		"SoSFVec2i32_setValue(SoSFVec2i32 self, int32_t x, int32_t y)\n"
		"SoSFVec2i32_setValue(SoSFVec2i32 self, int32_t const [2] xy)\n"
		""},
	 { "SoSFVec2i32_swigregister", SoSFVec2i32_swigregister, METH_O, NULL},
	 { "SoSFVec2i32_swiginit", SoSFVec2i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec2d", _wrap_new_SoSFVec2d, METH_NOARGS, "new_SoSFVec2d() -> SoSFVec2d"},
	 { "delete_SoSFVec2d", _wrap_delete_SoSFVec2d, METH_O, "delete_SoSFVec2d(SoSFVec2d self)"},
	 { "SoSFVec2d_createInstance", _wrap_SoSFVec2d_createInstance, METH_NOARGS, "SoSFVec2d_createInstance() -> void *"},
	 { "SoSFVec2d_getClassTypeId", _wrap_SoSFVec2d_getClassTypeId, METH_NOARGS, "SoSFVec2d_getClassTypeId() -> SoType"},
	 { "SoSFVec2d_getTypeId", _wrap_SoSFVec2d_getTypeId, METH_O, "SoSFVec2d_getTypeId(SoSFVec2d self) -> SoType"},
	 { "SoSFVec2d_copyFrom", _wrap_SoSFVec2d_copyFrom, METH_VARARGS, "SoSFVec2d_copyFrom(SoSFVec2d self, SoField field)"},
	 { "SoSFVec2d_isSame", _wrap_SoSFVec2d_isSame, METH_VARARGS, "SoSFVec2d_isSame(SoSFVec2d self, SoField field) -> SbBool"},
	 { "SoSFVec2d_getValue", _wrap_SoSFVec2d_getValue, METH_O, "SoSFVec2d_getValue(SoSFVec2d self) -> SbVec2d"},
	 { "SoSFVec2d___eq__", _wrap_SoSFVec2d___eq__, METH_VARARGS, "SoSFVec2d___eq__(SoSFVec2d self, SoSFVec2d field) -> int"},
	 { "SoSFVec2d___ne__", _wrap_SoSFVec2d___ne__, METH_VARARGS, "SoSFVec2d___ne__(SoSFVec2d self, SoSFVec2d field) -> int"},
	 { "SoSFVec2d_initClass", _wrap_SoSFVec2d_initClass, METH_NOARGS, "SoSFVec2d_initClass()"},
	 { "SoSFVec2d_setValue", _wrap_SoSFVec2d_setValue, METH_VARARGS, "\n"
		"SoSFVec2d_setValue(SoSFVec2d self, SbVec2d newvalue)\n"
		"SoSFVec2d_setValue(SoSFVec2d self, double x, double y)\n"
		"SoSFVec2d_setValue(SoSFVec2d self, double const [2] xy)\n"
		""},
	 { "SoSFVec2d_swigregister", SoSFVec2d_swigregister, METH_O, NULL},
	 { "SoSFVec2d_swiginit", SoSFVec2d_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec3b", _wrap_new_SbVec3b, METH_VARARGS, "\n"
		"SbVec3b()\n"
		"SbVec3b(int8_t const [3] v)\n"
		"SbVec3b(int8_t x, int8_t y, int8_t z)\n"
		"SbVec3b(SbVec3ub const & v)\n"
		"SbVec3b(SbVec3s v)\n"
		"SbVec3b(SbVec3i32 v)\n"
		"SbVec3b(SbVec3f v)\n"
		"new_SbVec3b(SbVec3d v) -> SbVec3b\n"
		""},
	 { "SbVec3b_setValue", _wrap_SbVec3b_setValue, METH_VARARGS, "\n"
		"SbVec3b_setValue(SbVec3b self, int8_t [3] v) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, int8_t x, int8_t y, int8_t z) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, SbVec3ub const & v) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, SbVec3s v) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, SbVec3i32 v) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, SbVec3f v) -> SbVec3b\n"
		"SbVec3b_setValue(SbVec3b self, SbVec3d v) -> SbVec3b\n"
		""},
	 { "SbVec3b_getValue", _wrap_SbVec3b_getValue, METH_VARARGS, "\n"
		"SbVec3b_getValue(SbVec3b self) -> int8_t const\n"
		"SbVec3b_getValue(SbVec3b self, int8_t & x, int8_t & y, int8_t & z)\n"
		""},
	 { "SbVec3b_dot", _wrap_SbVec3b_dot, METH_VARARGS, "SbVec3b_dot(SbVec3b self, SbVec3b v) -> int32_t"},
	 { "SbVec3b_negate", _wrap_SbVec3b_negate, METH_O, "SbVec3b_negate(SbVec3b self)"},
	 { "SbVec3b___imul__", _wrap_SbVec3b___imul__, METH_VARARGS, "\n"
		"SbVec3b___imul__(SbVec3b self, int d) -> SbVec3b\n"
		"SbVec3b___imul__(SbVec3b self, double d) -> SbVec3b\n"
		""},
	 { "SbVec3b___itruediv__", _wrap_SbVec3b___itruediv__, METH_VARARGS, "\n"
		"SbVec3b___itruediv__(SbVec3b self, int d) -> SbVec3b\n"
		"SbVec3b___itruediv__(SbVec3b self, double d) -> SbVec3b\n"
		""},
	 { "SbVec3b___iadd__", _wrap_SbVec3b___iadd__, METH_VARARGS, "SbVec3b___iadd__(SbVec3b self, SbVec3b v) -> SbVec3b"},
	 { "SbVec3b___isub__", _wrap_SbVec3b___isub__, METH_VARARGS, "SbVec3b___isub__(SbVec3b self, SbVec3b v) -> SbVec3b"},
	 { "SbVec3b___neg__", _wrap_SbVec3b___neg__, METH_O, "SbVec3b___neg__(SbVec3b self) -> SbVec3b"},
	 { "delete_SbVec3b", _wrap_delete_SbVec3b, METH_O, "delete_SbVec3b(SbVec3b self)"},
	 { "SbVec3b_swigregister", SbVec3b_swigregister, METH_O, NULL},
	 { "SbVec3b_swiginit", SbVec3b_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec3b", _wrap_new_SoSFVec3b, METH_NOARGS, "new_SoSFVec3b() -> SoSFVec3b"},
	 { "delete_SoSFVec3b", _wrap_delete_SoSFVec3b, METH_O, "delete_SoSFVec3b(SoSFVec3b self)"},
	 { "SoSFVec3b_createInstance", _wrap_SoSFVec3b_createInstance, METH_NOARGS, "SoSFVec3b_createInstance() -> void *"},
	 { "SoSFVec3b_getClassTypeId", _wrap_SoSFVec3b_getClassTypeId, METH_NOARGS, "SoSFVec3b_getClassTypeId() -> SoType"},
	 { "SoSFVec3b_getTypeId", _wrap_SoSFVec3b_getTypeId, METH_O, "SoSFVec3b_getTypeId(SoSFVec3b self) -> SoType"},
	 { "SoSFVec3b_copyFrom", _wrap_SoSFVec3b_copyFrom, METH_VARARGS, "SoSFVec3b_copyFrom(SoSFVec3b self, SoField field)"},
	 { "SoSFVec3b_isSame", _wrap_SoSFVec3b_isSame, METH_VARARGS, "SoSFVec3b_isSame(SoSFVec3b self, SoField field) -> SbBool"},
	 { "SoSFVec3b_getValue", _wrap_SoSFVec3b_getValue, METH_O, "SoSFVec3b_getValue(SoSFVec3b self) -> SbVec3b"},
	 { "SoSFVec3b___eq__", _wrap_SoSFVec3b___eq__, METH_VARARGS, "SoSFVec3b___eq__(SoSFVec3b self, SoSFVec3b field) -> int"},
	 { "SoSFVec3b___ne__", _wrap_SoSFVec3b___ne__, METH_VARARGS, "SoSFVec3b___ne__(SoSFVec3b self, SoSFVec3b field) -> int"},
	 { "SoSFVec3b_initClass", _wrap_SoSFVec3b_initClass, METH_NOARGS, "SoSFVec3b_initClass()"},
	 { "SoSFVec3b_setValue", _wrap_SoSFVec3b_setValue, METH_VARARGS, "\n"
		"SoSFVec3b_setValue(SoSFVec3b self, SbVec3b newvalue)\n"
		"SoSFVec3b_setValue(SoSFVec3b self, int8_t x, int8_t y, int8_t z)\n"
		"SoSFVec3b_setValue(SoSFVec3b self, int8_t const [3] xyz)\n"
		""},
	 { "SoSFVec3b_swigregister", SoSFVec3b_swigregister, METH_O, NULL},
	 { "SoSFVec3b_swiginit", SoSFVec3b_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec3s", _wrap_new_SoSFVec3s, METH_NOARGS, "new_SoSFVec3s() -> SoSFVec3s"},
	 { "delete_SoSFVec3s", _wrap_delete_SoSFVec3s, METH_O, "delete_SoSFVec3s(SoSFVec3s self)"},
	 { "SoSFVec3s_createInstance", _wrap_SoSFVec3s_createInstance, METH_NOARGS, "SoSFVec3s_createInstance() -> void *"},
	 { "SoSFVec3s_getClassTypeId", _wrap_SoSFVec3s_getClassTypeId, METH_NOARGS, "SoSFVec3s_getClassTypeId() -> SoType"},
	 { "SoSFVec3s_getTypeId", _wrap_SoSFVec3s_getTypeId, METH_O, "SoSFVec3s_getTypeId(SoSFVec3s self) -> SoType"},
	 { "SoSFVec3s_copyFrom", _wrap_SoSFVec3s_copyFrom, METH_VARARGS, "SoSFVec3s_copyFrom(SoSFVec3s self, SoField field)"},
	 { "SoSFVec3s_isSame", _wrap_SoSFVec3s_isSame, METH_VARARGS, "SoSFVec3s_isSame(SoSFVec3s self, SoField field) -> SbBool"},
	 { "SoSFVec3s_getValue", _wrap_SoSFVec3s_getValue, METH_O, "SoSFVec3s_getValue(SoSFVec3s self) -> SbVec3s"},
	 { "SoSFVec3s___eq__", _wrap_SoSFVec3s___eq__, METH_VARARGS, "SoSFVec3s___eq__(SoSFVec3s self, SoSFVec3s field) -> int"},
	 { "SoSFVec3s___ne__", _wrap_SoSFVec3s___ne__, METH_VARARGS, "SoSFVec3s___ne__(SoSFVec3s self, SoSFVec3s field) -> int"},
	 { "SoSFVec3s_initClass", _wrap_SoSFVec3s_initClass, METH_NOARGS, "SoSFVec3s_initClass()"},
	 { "SoSFVec3s_setValue", _wrap_SoSFVec3s_setValue, METH_VARARGS, "\n"
		"SoSFVec3s_setValue(SoSFVec3s self, SbVec3s newvalue)\n"
		"SoSFVec3s_setValue(SoSFVec3s self, short x, short y, short z)\n"
		"SoSFVec3s_setValue(SoSFVec3s self, short const [3] xyz)\n"
		""},
	 { "SoSFVec3s_swigregister", SoSFVec3s_swigregister, METH_O, NULL},
	 { "SoSFVec3s_swiginit", SoSFVec3s_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec3i32", _wrap_new_SoSFVec3i32, METH_NOARGS, "new_SoSFVec3i32() -> SoSFVec3i32"},
	 { "delete_SoSFVec3i32", _wrap_delete_SoSFVec3i32, METH_O, "delete_SoSFVec3i32(SoSFVec3i32 self)"},
	 { "SoSFVec3i32_createInstance", _wrap_SoSFVec3i32_createInstance, METH_NOARGS, "SoSFVec3i32_createInstance() -> void *"},
	 { "SoSFVec3i32_getClassTypeId", _wrap_SoSFVec3i32_getClassTypeId, METH_NOARGS, "SoSFVec3i32_getClassTypeId() -> SoType"},
	 { "SoSFVec3i32_getTypeId", _wrap_SoSFVec3i32_getTypeId, METH_O, "SoSFVec3i32_getTypeId(SoSFVec3i32 self) -> SoType"},
	 { "SoSFVec3i32_copyFrom", _wrap_SoSFVec3i32_copyFrom, METH_VARARGS, "SoSFVec3i32_copyFrom(SoSFVec3i32 self, SoField field)"},
	 { "SoSFVec3i32_isSame", _wrap_SoSFVec3i32_isSame, METH_VARARGS, "SoSFVec3i32_isSame(SoSFVec3i32 self, SoField field) -> SbBool"},
	 { "SoSFVec3i32_getValue", _wrap_SoSFVec3i32_getValue, METH_O, "SoSFVec3i32_getValue(SoSFVec3i32 self) -> SbVec3i32"},
	 { "SoSFVec3i32___eq__", _wrap_SoSFVec3i32___eq__, METH_VARARGS, "SoSFVec3i32___eq__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"},
	 { "SoSFVec3i32___ne__", _wrap_SoSFVec3i32___ne__, METH_VARARGS, "SoSFVec3i32___ne__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"},
	 { "SoSFVec3i32_initClass", _wrap_SoSFVec3i32_initClass, METH_NOARGS, "SoSFVec3i32_initClass()"},
	 { "SoSFVec3i32_setValue", _wrap_SoSFVec3i32_setValue, METH_VARARGS, "\n"
		"SoSFVec3i32_setValue(SoSFVec3i32 self, SbVec3i32 newvalue)\n"
		"SoSFVec3i32_setValue(SoSFVec3i32 self, int32_t x, int32_t y, int32_t z)\n"
		"SoSFVec3i32_setValue(SoSFVec3i32 self, int32_t const [3] xyz)\n"
		""},
	 { "SoSFVec3i32_swigregister", SoSFVec3i32_swigregister, METH_O, NULL},
	 { "SoSFVec3i32_swiginit", SoSFVec3i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec3d", _wrap_new_SoSFVec3d, METH_NOARGS, "new_SoSFVec3d() -> SoSFVec3d"},
	 { "delete_SoSFVec3d", _wrap_delete_SoSFVec3d, METH_O, "delete_SoSFVec3d(SoSFVec3d self)"},
	 { "SoSFVec3d_createInstance", _wrap_SoSFVec3d_createInstance, METH_NOARGS, "SoSFVec3d_createInstance() -> void *"},
	 { "SoSFVec3d_getClassTypeId", _wrap_SoSFVec3d_getClassTypeId, METH_NOARGS, "SoSFVec3d_getClassTypeId() -> SoType"},
	 { "SoSFVec3d_getTypeId", _wrap_SoSFVec3d_getTypeId, METH_O, "SoSFVec3d_getTypeId(SoSFVec3d self) -> SoType"},
	 { "SoSFVec3d_copyFrom", _wrap_SoSFVec3d_copyFrom, METH_VARARGS, "SoSFVec3d_copyFrom(SoSFVec3d self, SoField field)"},
	 { "SoSFVec3d_isSame", _wrap_SoSFVec3d_isSame, METH_VARARGS, "SoSFVec3d_isSame(SoSFVec3d self, SoField field) -> SbBool"},
	 { "SoSFVec3d_getValue", _wrap_SoSFVec3d_getValue, METH_O, "SoSFVec3d_getValue(SoSFVec3d self) -> SbVec3d"},
	 { "SoSFVec3d___eq__", _wrap_SoSFVec3d___eq__, METH_VARARGS, "SoSFVec3d___eq__(SoSFVec3d self, SoSFVec3d field) -> int"},
	 { "SoSFVec3d___ne__", _wrap_SoSFVec3d___ne__, METH_VARARGS, "SoSFVec3d___ne__(SoSFVec3d self, SoSFVec3d field) -> int"},
	 { "SoSFVec3d_initClass", _wrap_SoSFVec3d_initClass, METH_NOARGS, "SoSFVec3d_initClass()"},
	 { "SoSFVec3d_setValue", _wrap_SoSFVec3d_setValue, METH_VARARGS, "\n"
		"SoSFVec3d_setValue(SoSFVec3d self, SbVec3d newvalue)\n"
		"SoSFVec3d_setValue(SoSFVec3d self, double x, double y, double z)\n"
		"SoSFVec3d_setValue(SoSFVec3d self, double const [3] xyz)\n"
		""},
	 { "SoSFVec3d_swigregister", SoSFVec3d_swigregister, METH_O, NULL},
	 { "SoSFVec3d_swiginit", SoSFVec3d_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4b", _wrap_new_SbVec4b, METH_VARARGS, "\n"
		"SbVec4b()\n"
		"SbVec4b(int8_t const [4] v)\n"
		"SbVec4b(int8_t x, int8_t y, int8_t z, int8_t w)\n"
		"SbVec4b(SbVec4ub v)\n"
		"SbVec4b(SbVec4s v)\n"
		"SbVec4b(SbVec4i32 v)\n"
		"SbVec4b(SbVec4f v)\n"
		"new_SbVec4b(SbVec4d v) -> SbVec4b\n"
		""},
	 { "SbVec4b_setValue", _wrap_SbVec4b_setValue, METH_VARARGS, "\n"
		"SbVec4b_setValue(SbVec4b self, int8_t const [4] v) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, SbVec4ub v) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, SbVec4s v) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, SbVec4i32 v) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, SbVec4f v) -> SbVec4b\n"
		"SbVec4b_setValue(SbVec4b self, SbVec4d v) -> SbVec4b\n"
		""},
	 { "SbVec4b_getValue", _wrap_SbVec4b_getValue, METH_VARARGS, "\n"
		"SbVec4b_getValue(SbVec4b self) -> int8_t const\n"
		"SbVec4b_getValue(SbVec4b self, int8_t & x, int8_t & y, int8_t & z, int8_t & w)\n"
		""},
	 { "SbVec4b_dot", _wrap_SbVec4b_dot, METH_VARARGS, "SbVec4b_dot(SbVec4b self, SbVec4b v) -> int32_t"},
	 { "SbVec4b_negate", _wrap_SbVec4b_negate, METH_O, "SbVec4b_negate(SbVec4b self)"},
	 { "SbVec4b___imul__", _wrap_SbVec4b___imul__, METH_VARARGS, "\n"
		"SbVec4b___imul__(SbVec4b self, int d) -> SbVec4b\n"
		"SbVec4b___imul__(SbVec4b self, double d) -> SbVec4b\n"
		""},
	 { "SbVec4b___itruediv__", _wrap_SbVec4b___itruediv__, METH_VARARGS, "\n"
		"SbVec4b___itruediv__(SbVec4b self, int d) -> SbVec4b\n"
		"SbVec4b___itruediv__(SbVec4b self, double d) -> SbVec4b\n"
		""},
	 { "SbVec4b___iadd__", _wrap_SbVec4b___iadd__, METH_VARARGS, "SbVec4b___iadd__(SbVec4b self, SbVec4b v) -> SbVec4b"},
	 { "SbVec4b___isub__", _wrap_SbVec4b___isub__, METH_VARARGS, "SbVec4b___isub__(SbVec4b self, SbVec4b v) -> SbVec4b"},
	 { "SbVec4b___neg__", _wrap_SbVec4b___neg__, METH_O, "SbVec4b___neg__(SbVec4b self) -> SbVec4b"},
	 { "delete_SbVec4b", _wrap_delete_SbVec4b, METH_O, "delete_SbVec4b(SbVec4b self)"},
	 { "SbVec4b_swigregister", SbVec4b_swigregister, METH_O, NULL},
	 { "SbVec4b_swiginit", SbVec4b_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4b", _wrap_new_SoSFVec4b, METH_NOARGS, "new_SoSFVec4b() -> SoSFVec4b"},
	 { "delete_SoSFVec4b", _wrap_delete_SoSFVec4b, METH_O, "delete_SoSFVec4b(SoSFVec4b self)"},
	 { "SoSFVec4b_createInstance", _wrap_SoSFVec4b_createInstance, METH_NOARGS, "SoSFVec4b_createInstance() -> void *"},
	 { "SoSFVec4b_getClassTypeId", _wrap_SoSFVec4b_getClassTypeId, METH_NOARGS, "SoSFVec4b_getClassTypeId() -> SoType"},
	 { "SoSFVec4b_getTypeId", _wrap_SoSFVec4b_getTypeId, METH_O, "SoSFVec4b_getTypeId(SoSFVec4b self) -> SoType"},
	 { "SoSFVec4b_copyFrom", _wrap_SoSFVec4b_copyFrom, METH_VARARGS, "SoSFVec4b_copyFrom(SoSFVec4b self, SoField field)"},
	 { "SoSFVec4b_isSame", _wrap_SoSFVec4b_isSame, METH_VARARGS, "SoSFVec4b_isSame(SoSFVec4b self, SoField field) -> SbBool"},
	 { "SoSFVec4b_getValue", _wrap_SoSFVec4b_getValue, METH_O, "SoSFVec4b_getValue(SoSFVec4b self) -> SbVec4b"},
	 { "SoSFVec4b___eq__", _wrap_SoSFVec4b___eq__, METH_VARARGS, "SoSFVec4b___eq__(SoSFVec4b self, SoSFVec4b field) -> int"},
	 { "SoSFVec4b___ne__", _wrap_SoSFVec4b___ne__, METH_VARARGS, "SoSFVec4b___ne__(SoSFVec4b self, SoSFVec4b field) -> int"},
	 { "SoSFVec4b_initClass", _wrap_SoSFVec4b_initClass, METH_NOARGS, "SoSFVec4b_initClass()"},
	 { "SoSFVec4b_setValue", _wrap_SoSFVec4b_setValue, METH_VARARGS, "\n"
		"SoSFVec4b_setValue(SoSFVec4b self, SbVec4b newvalue)\n"
		"SoSFVec4b_setValue(SoSFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)\n"
		"SoSFVec4b_setValue(SoSFVec4b self, int8_t const [4] xyzw)\n"
		""},
	 { "SoSFVec4b_swigregister", SoSFVec4b_swigregister, METH_O, NULL},
	 { "SoSFVec4b_swiginit", SoSFVec4b_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4ub", _wrap_new_SbVec4ub, METH_VARARGS, "\n"
		"SbVec4ub()\n"
		"SbVec4ub(uint8_t const [4] v)\n"
		"SbVec4ub(uint8_t x, uint8_t y, uint8_t z, uint8_t w)\n"
		"SbVec4ub(SbVec4b v)\n"
		"SbVec4ub(SbVec4us v)\n"
		"new_SbVec4ub(SbVec4ui32 v) -> SbVec4ub\n"
		""},
	 { "SbVec4ub_setValue", _wrap_SbVec4ub_setValue, METH_VARARGS, "\n"
		"SbVec4ub_setValue(SbVec4ub self, uint8_t const [4] v) -> SbVec4ub\n"
		"SbVec4ub_setValue(SbVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub\n"
		"SbVec4ub_setValue(SbVec4ub self, SbVec4b v) -> SbVec4ub\n"
		"SbVec4ub_setValue(SbVec4ub self, SbVec4us v) -> SbVec4ub\n"
		"SbVec4ub_setValue(SbVec4ub self, SbVec4ui32 v) -> SbVec4ub\n"
		""},
	 { "SbVec4ub_getValue", _wrap_SbVec4ub_getValue, METH_VARARGS, "\n"
		"SbVec4ub_getValue(SbVec4ub self) -> uint8_t const\n"
		"SbVec4ub_getValue(SbVec4ub self, uint8_t & x, uint8_t & y, uint8_t & z, uint8_t & w)\n"
		""},
	 { "SbVec4ub_dot", _wrap_SbVec4ub_dot, METH_VARARGS, "SbVec4ub_dot(SbVec4ub self, SbVec4ub v) -> int32_t"},
	 { "SbVec4ub_negate", _wrap_SbVec4ub_negate, METH_O, "SbVec4ub_negate(SbVec4ub self)"},
	 { "SbVec4ub___imul__", _wrap_SbVec4ub___imul__, METH_VARARGS, "\n"
		"SbVec4ub___imul__(SbVec4ub self, int d) -> SbVec4ub\n"
		"SbVec4ub___imul__(SbVec4ub self, double d) -> SbVec4ub\n"
		""},
	 { "SbVec4ub___itruediv__", _wrap_SbVec4ub___itruediv__, METH_VARARGS, "\n"
		"SbVec4ub___itruediv__(SbVec4ub self, int d) -> SbVec4ub\n"
		"SbVec4ub___itruediv__(SbVec4ub self, double d) -> SbVec4ub\n"
		""},
	 { "SbVec4ub___iadd__", _wrap_SbVec4ub___iadd__, METH_VARARGS, "SbVec4ub___iadd__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"},
	 { "SbVec4ub___isub__", _wrap_SbVec4ub___isub__, METH_VARARGS, "SbVec4ub___isub__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"},
	 { "SbVec4ub___neg__", _wrap_SbVec4ub___neg__, METH_O, "SbVec4ub___neg__(SbVec4ub self) -> SbVec4ub"},
	 { "delete_SbVec4ub", _wrap_delete_SbVec4ub, METH_O, "delete_SbVec4ub(SbVec4ub self)"},
	 { "SbVec4ub_swigregister", SbVec4ub_swigregister, METH_O, NULL},
	 { "SbVec4ub_swiginit", SbVec4ub_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4ub", _wrap_new_SoSFVec4ub, METH_NOARGS, "new_SoSFVec4ub() -> SoSFVec4ub"},
	 { "delete_SoSFVec4ub", _wrap_delete_SoSFVec4ub, METH_O, "delete_SoSFVec4ub(SoSFVec4ub self)"},
	 { "SoSFVec4ub_createInstance", _wrap_SoSFVec4ub_createInstance, METH_NOARGS, "SoSFVec4ub_createInstance() -> void *"},
	 { "SoSFVec4ub_getClassTypeId", _wrap_SoSFVec4ub_getClassTypeId, METH_NOARGS, "SoSFVec4ub_getClassTypeId() -> SoType"},
	 { "SoSFVec4ub_getTypeId", _wrap_SoSFVec4ub_getTypeId, METH_O, "SoSFVec4ub_getTypeId(SoSFVec4ub self) -> SoType"},
	 { "SoSFVec4ub_copyFrom", _wrap_SoSFVec4ub_copyFrom, METH_VARARGS, "SoSFVec4ub_copyFrom(SoSFVec4ub self, SoField field)"},
	 { "SoSFVec4ub_isSame", _wrap_SoSFVec4ub_isSame, METH_VARARGS, "SoSFVec4ub_isSame(SoSFVec4ub self, SoField field) -> SbBool"},
	 { "SoSFVec4ub_getValue", _wrap_SoSFVec4ub_getValue, METH_O, "SoSFVec4ub_getValue(SoSFVec4ub self) -> SbVec4ub"},
	 { "SoSFVec4ub___eq__", _wrap_SoSFVec4ub___eq__, METH_VARARGS, "SoSFVec4ub___eq__(SoSFVec4ub self, SoSFVec4ub field) -> int"},
	 { "SoSFVec4ub___ne__", _wrap_SoSFVec4ub___ne__, METH_VARARGS, "SoSFVec4ub___ne__(SoSFVec4ub self, SoSFVec4ub field) -> int"},
	 { "SoSFVec4ub_initClass", _wrap_SoSFVec4ub_initClass, METH_NOARGS, "SoSFVec4ub_initClass()"},
	 { "SoSFVec4ub_setValue", _wrap_SoSFVec4ub_setValue, METH_VARARGS, "\n"
		"SoSFVec4ub_setValue(SoSFVec4ub self, SbVec4ub newvalue)\n"
		"SoSFVec4ub_setValue(SoSFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)\n"
		"SoSFVec4ub_setValue(SoSFVec4ub self, uint8_t const [4] xyzw)\n"
		""},
	 { "SoSFVec4ub_swigregister", SoSFVec4ub_swigregister, METH_O, NULL},
	 { "SoSFVec4ub_swiginit", SoSFVec4ub_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4s", _wrap_new_SbVec4s, METH_VARARGS, "\n"
		"SbVec4s()\n"
		"SbVec4s(short const [4] v)\n"
		"SbVec4s(short x, short y, short z, short w)\n"
		"SbVec4s(SbVec4us v)\n"
		"SbVec4s(SbVec4b v)\n"
		"SbVec4s(SbVec4i32 v)\n"
		"SbVec4s(SbVec4f v)\n"
		"new_SbVec4s(SbVec4d v) -> SbVec4s\n"
		""},
	 { "SbVec4s_setValue", _wrap_SbVec4s_setValue, METH_VARARGS, "\n"
		"SbVec4s_setValue(SbVec4s self, short const [4] v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, short x, short y, short z, short w) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4s v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4us v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4b v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4i32 v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4f v) -> SbVec4s\n"
		"SbVec4s_setValue(SbVec4s self, SbVec4d v) -> SbVec4s\n"
		""},
	 { "SbVec4s_getValue", _wrap_SbVec4s_getValue, METH_VARARGS, "\n"
		"SbVec4s_getValue(SbVec4s self) -> short const\n"
		"SbVec4s_getValue(SbVec4s self, short & w)\n"
		""},
	 { "SbVec4s_dot", _wrap_SbVec4s_dot, METH_VARARGS, "SbVec4s_dot(SbVec4s self, SbVec4s v) -> int32_t"},
	 { "SbVec4s_negate", _wrap_SbVec4s_negate, METH_O, "SbVec4s_negate(SbVec4s self)"},
	 { "SbVec4s___imul__", _wrap_SbVec4s___imul__, METH_VARARGS, "\n"
		"SbVec4s___imul__(SbVec4s self, int d) -> SbVec4s\n"
		"SbVec4s___imul__(SbVec4s self, double d) -> SbVec4s\n"
		""},
	 { "SbVec4s___itruediv__", _wrap_SbVec4s___itruediv__, METH_VARARGS, "\n"
		"SbVec4s___itruediv__(SbVec4s self, int d) -> SbVec4s\n"
		"SbVec4s___itruediv__(SbVec4s self, double d) -> SbVec4s\n"
		""},
	 { "SbVec4s___iadd__", _wrap_SbVec4s___iadd__, METH_VARARGS, "SbVec4s___iadd__(SbVec4s self, SbVec4s v) -> SbVec4s"},
	 { "SbVec4s___isub__", _wrap_SbVec4s___isub__, METH_VARARGS, "SbVec4s___isub__(SbVec4s self, SbVec4s v) -> SbVec4s"},
	 { "SbVec4s___neg__", _wrap_SbVec4s___neg__, METH_O, "SbVec4s___neg__(SbVec4s self) -> SbVec4s"},
	 { "delete_SbVec4s", _wrap_delete_SbVec4s, METH_O, "delete_SbVec4s(SbVec4s self)"},
	 { "SbVec4s_swigregister", SbVec4s_swigregister, METH_O, NULL},
	 { "SbVec4s_swiginit", SbVec4s_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4s", _wrap_new_SoSFVec4s, METH_NOARGS, "new_SoSFVec4s() -> SoSFVec4s"},
	 { "delete_SoSFVec4s", _wrap_delete_SoSFVec4s, METH_O, "delete_SoSFVec4s(SoSFVec4s self)"},
	 { "SoSFVec4s_createInstance", _wrap_SoSFVec4s_createInstance, METH_NOARGS, "SoSFVec4s_createInstance() -> void *"},
	 { "SoSFVec4s_getClassTypeId", _wrap_SoSFVec4s_getClassTypeId, METH_NOARGS, "SoSFVec4s_getClassTypeId() -> SoType"},
	 { "SoSFVec4s_getTypeId", _wrap_SoSFVec4s_getTypeId, METH_O, "SoSFVec4s_getTypeId(SoSFVec4s self) -> SoType"},
	 { "SoSFVec4s_copyFrom", _wrap_SoSFVec4s_copyFrom, METH_VARARGS, "SoSFVec4s_copyFrom(SoSFVec4s self, SoField field)"},
	 { "SoSFVec4s_isSame", _wrap_SoSFVec4s_isSame, METH_VARARGS, "SoSFVec4s_isSame(SoSFVec4s self, SoField field) -> SbBool"},
	 { "SoSFVec4s_getValue", _wrap_SoSFVec4s_getValue, METH_O, "SoSFVec4s_getValue(SoSFVec4s self) -> SbVec4s"},
	 { "SoSFVec4s___eq__", _wrap_SoSFVec4s___eq__, METH_VARARGS, "SoSFVec4s___eq__(SoSFVec4s self, SoSFVec4s field) -> int"},
	 { "SoSFVec4s___ne__", _wrap_SoSFVec4s___ne__, METH_VARARGS, "SoSFVec4s___ne__(SoSFVec4s self, SoSFVec4s field) -> int"},
	 { "SoSFVec4s_initClass", _wrap_SoSFVec4s_initClass, METH_NOARGS, "SoSFVec4s_initClass()"},
	 { "SoSFVec4s_setValue", _wrap_SoSFVec4s_setValue, METH_VARARGS, "\n"
		"SoSFVec4s_setValue(SoSFVec4s self, SbVec4s newvalue)\n"
		"SoSFVec4s_setValue(SoSFVec4s self, short x, short y, short z, short w)\n"
		"SoSFVec4s_setValue(SoSFVec4s self, short const [4] xyzw)\n"
		""},
	 { "SoSFVec4s_swigregister", SoSFVec4s_swigregister, METH_O, NULL},
	 { "SoSFVec4s_swiginit", SoSFVec4s_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4us", _wrap_new_SbVec4us, METH_VARARGS, "\n"
		"SbVec4us()\n"
		"SbVec4us(unsigned short const [4] v)\n"
		"SbVec4us(unsigned short x, unsigned short y, unsigned short z, unsigned short w)\n"
		"SbVec4us(SbVec4s v)\n"
		"SbVec4us(SbVec4ub v)\n"
		"new_SbVec4us(SbVec4ui32 v) -> SbVec4us\n"
		""},
	 { "SbVec4us_setValue", _wrap_SbVec4us_setValue, METH_VARARGS, "\n"
		"SbVec4us_setValue(SbVec4us self, unsigned short const [4] v) -> SbVec4us\n"
		"SbVec4us_setValue(SbVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w) -> SbVec4us\n"
		"SbVec4us_setValue(SbVec4us self, SbVec4s v) -> SbVec4us\n"
		"SbVec4us_setValue(SbVec4us self, SbVec4ub v) -> SbVec4us\n"
		"SbVec4us_setValue(SbVec4us self, SbVec4ui32 v) -> SbVec4us\n"
		""},
	 { "SbVec4us_getValue", _wrap_SbVec4us_getValue, METH_VARARGS, "\n"
		"SbVec4us_getValue(SbVec4us self) -> unsigned short const\n"
		"SbVec4us_getValue(SbVec4us self, unsigned short & x, unsigned short & y, unsigned short & z, unsigned short & w)\n"
		""},
	 { "SbVec4us_dot", _wrap_SbVec4us_dot, METH_VARARGS, "SbVec4us_dot(SbVec4us self, SbVec4us v) -> int32_t"},
	 { "SbVec4us_negate", _wrap_SbVec4us_negate, METH_O, "SbVec4us_negate(SbVec4us self)"},
	 { "SbVec4us___imul__", _wrap_SbVec4us___imul__, METH_VARARGS, "\n"
		"SbVec4us___imul__(SbVec4us self, int d) -> SbVec4us\n"
		"SbVec4us___imul__(SbVec4us self, double d) -> SbVec4us\n"
		""},
	 { "SbVec4us___itruediv__", _wrap_SbVec4us___itruediv__, METH_VARARGS, "\n"
		"SbVec4us___itruediv__(SbVec4us self, int d) -> SbVec4us\n"
		"SbVec4us___itruediv__(SbVec4us self, double d) -> SbVec4us\n"
		""},
	 { "SbVec4us___iadd__", _wrap_SbVec4us___iadd__, METH_VARARGS, "SbVec4us___iadd__(SbVec4us self, SbVec4us v) -> SbVec4us"},
	 { "SbVec4us___isub__", _wrap_SbVec4us___isub__, METH_VARARGS, "SbVec4us___isub__(SbVec4us self, SbVec4us v) -> SbVec4us"},
	 { "SbVec4us___neg__", _wrap_SbVec4us___neg__, METH_O, "SbVec4us___neg__(SbVec4us self) -> SbVec4us"},
	 { "delete_SbVec4us", _wrap_delete_SbVec4us, METH_O, "delete_SbVec4us(SbVec4us self)"},
	 { "SbVec4us_swigregister", SbVec4us_swigregister, METH_O, NULL},
	 { "SbVec4us_swiginit", SbVec4us_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4us", _wrap_new_SoSFVec4us, METH_NOARGS, "new_SoSFVec4us() -> SoSFVec4us"},
	 { "delete_SoSFVec4us", _wrap_delete_SoSFVec4us, METH_O, "delete_SoSFVec4us(SoSFVec4us self)"},
	 { "SoSFVec4us_createInstance", _wrap_SoSFVec4us_createInstance, METH_NOARGS, "SoSFVec4us_createInstance() -> void *"},
	 { "SoSFVec4us_getClassTypeId", _wrap_SoSFVec4us_getClassTypeId, METH_NOARGS, "SoSFVec4us_getClassTypeId() -> SoType"},
	 { "SoSFVec4us_getTypeId", _wrap_SoSFVec4us_getTypeId, METH_O, "SoSFVec4us_getTypeId(SoSFVec4us self) -> SoType"},
	 { "SoSFVec4us_copyFrom", _wrap_SoSFVec4us_copyFrom, METH_VARARGS, "SoSFVec4us_copyFrom(SoSFVec4us self, SoField field)"},
	 { "SoSFVec4us_isSame", _wrap_SoSFVec4us_isSame, METH_VARARGS, "SoSFVec4us_isSame(SoSFVec4us self, SoField field) -> SbBool"},
	 { "SoSFVec4us_getValue", _wrap_SoSFVec4us_getValue, METH_O, "SoSFVec4us_getValue(SoSFVec4us self) -> SbVec4us"},
	 { "SoSFVec4us___eq__", _wrap_SoSFVec4us___eq__, METH_VARARGS, "SoSFVec4us___eq__(SoSFVec4us self, SoSFVec4us field) -> int"},
	 { "SoSFVec4us___ne__", _wrap_SoSFVec4us___ne__, METH_VARARGS, "SoSFVec4us___ne__(SoSFVec4us self, SoSFVec4us field) -> int"},
	 { "SoSFVec4us_initClass", _wrap_SoSFVec4us_initClass, METH_NOARGS, "SoSFVec4us_initClass()"},
	 { "SoSFVec4us_setValue", _wrap_SoSFVec4us_setValue, METH_VARARGS, "\n"
		"SoSFVec4us_setValue(SoSFVec4us self, SbVec4us newvalue)\n"
		"SoSFVec4us_setValue(SoSFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)\n"
		"SoSFVec4us_setValue(SoSFVec4us self, unsigned short const [4] xyzw)\n"
		""},
	 { "SoSFVec4us_swigregister", SoSFVec4us_swigregister, METH_O, NULL},
	 { "SoSFVec4us_swiginit", SoSFVec4us_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4i32", _wrap_new_SbVec4i32, METH_VARARGS, "\n"
		"SbVec4i32()\n"
		"SbVec4i32(int32_t const [4] v)\n"
		"SbVec4i32(int32_t x, int32_t y, int32_t z, int32_t w)\n"
		"SbVec4i32(SbVec4ui32 v)\n"
		"SbVec4i32(SbVec4b v)\n"
		"SbVec4i32(SbVec4s v)\n"
		"SbVec4i32(SbVec4f v)\n"
		"new_SbVec4i32(SbVec4d v) -> SbVec4i32\n"
		""},
	 { "SbVec4i32_setValue", _wrap_SbVec4i32_setValue, METH_VARARGS, "\n"
		"SbVec4i32_setValue(SbVec4i32 self, int32_t const [4] v) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, SbVec4ui32 v) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, SbVec4b v) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, SbVec4s v) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, SbVec4f v) -> SbVec4i32\n"
		"SbVec4i32_setValue(SbVec4i32 self, SbVec4d v) -> SbVec4i32\n"
		""},
	 { "SbVec4i32_getValue", _wrap_SbVec4i32_getValue, METH_VARARGS, "\n"
		"SbVec4i32_getValue(SbVec4i32 self) -> int32_t const\n"
		"SbVec4i32_getValue(SbVec4i32 self, int32_t & x, int32_t & y, int32_t & z, int32_t & w)\n"
		""},
	 { "SbVec4i32_dot", _wrap_SbVec4i32_dot, METH_VARARGS, "SbVec4i32_dot(SbVec4i32 self, SbVec4i32 v) -> int32_t"},
	 { "SbVec4i32_negate", _wrap_SbVec4i32_negate, METH_O, "SbVec4i32_negate(SbVec4i32 self)"},
	 { "SbVec4i32___imul__", _wrap_SbVec4i32___imul__, METH_VARARGS, "\n"
		"SbVec4i32___imul__(SbVec4i32 self, int d) -> SbVec4i32\n"
		"SbVec4i32___imul__(SbVec4i32 self, double d) -> SbVec4i32\n"
		""},
	 { "SbVec4i32___itruediv__", _wrap_SbVec4i32___itruediv__, METH_VARARGS, "\n"
		"SbVec4i32___itruediv__(SbVec4i32 self, int d) -> SbVec4i32\n"
		"SbVec4i32___itruediv__(SbVec4i32 self, double d) -> SbVec4i32\n"
		""},
	 { "SbVec4i32___iadd__", _wrap_SbVec4i32___iadd__, METH_VARARGS, "SbVec4i32___iadd__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"},
	 { "SbVec4i32___isub__", _wrap_SbVec4i32___isub__, METH_VARARGS, "SbVec4i32___isub__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"},
	 { "SbVec4i32___neg__", _wrap_SbVec4i32___neg__, METH_O, "SbVec4i32___neg__(SbVec4i32 self) -> SbVec4i32"},
	 { "delete_SbVec4i32", _wrap_delete_SbVec4i32, METH_O, "delete_SbVec4i32(SbVec4i32 self)"},
	 { "SbVec4i32_swigregister", SbVec4i32_swigregister, METH_O, NULL},
	 { "SbVec4i32_swiginit", SbVec4i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4i32", _wrap_new_SoSFVec4i32, METH_NOARGS, "new_SoSFVec4i32() -> SoSFVec4i32"},
	 { "delete_SoSFVec4i32", _wrap_delete_SoSFVec4i32, METH_O, "delete_SoSFVec4i32(SoSFVec4i32 self)"},
	 { "SoSFVec4i32_createInstance", _wrap_SoSFVec4i32_createInstance, METH_NOARGS, "SoSFVec4i32_createInstance() -> void *"},
	 { "SoSFVec4i32_getClassTypeId", _wrap_SoSFVec4i32_getClassTypeId, METH_NOARGS, "SoSFVec4i32_getClassTypeId() -> SoType"},
	 { "SoSFVec4i32_getTypeId", _wrap_SoSFVec4i32_getTypeId, METH_O, "SoSFVec4i32_getTypeId(SoSFVec4i32 self) -> SoType"},
	 { "SoSFVec4i32_copyFrom", _wrap_SoSFVec4i32_copyFrom, METH_VARARGS, "SoSFVec4i32_copyFrom(SoSFVec4i32 self, SoField field)"},
	 { "SoSFVec4i32_isSame", _wrap_SoSFVec4i32_isSame, METH_VARARGS, "SoSFVec4i32_isSame(SoSFVec4i32 self, SoField field) -> SbBool"},
	 { "SoSFVec4i32_getValue", _wrap_SoSFVec4i32_getValue, METH_O, "SoSFVec4i32_getValue(SoSFVec4i32 self) -> SbVec4i32"},
	 { "SoSFVec4i32___eq__", _wrap_SoSFVec4i32___eq__, METH_VARARGS, "SoSFVec4i32___eq__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"},
	 { "SoSFVec4i32___ne__", _wrap_SoSFVec4i32___ne__, METH_VARARGS, "SoSFVec4i32___ne__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"},
	 { "SoSFVec4i32_initClass", _wrap_SoSFVec4i32_initClass, METH_NOARGS, "SoSFVec4i32_initClass()"},
	 { "SoSFVec4i32_setValue", _wrap_SoSFVec4i32_setValue, METH_VARARGS, "\n"
		"SoSFVec4i32_setValue(SoSFVec4i32 self, SbVec4i32 newvalue)\n"
		"SoSFVec4i32_setValue(SoSFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)\n"
		"SoSFVec4i32_setValue(SoSFVec4i32 self, int32_t const [4] xyzw)\n"
		""},
	 { "SoSFVec4i32_swigregister", SoSFVec4i32_swigregister, METH_O, NULL},
	 { "SoSFVec4i32_swiginit", SoSFVec4i32_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4ui32", _wrap_new_SbVec4ui32, METH_VARARGS, "\n"
		"SbVec4ui32()\n"
		"SbVec4ui32(uint32_t const [4] v)\n"
		"SbVec4ui32(uint32_t x, uint32_t y, uint32_t z, uint32_t w)\n"
		"SbVec4ui32(SbVec4i32 v)\n"
		"SbVec4ui32(SbVec4ub v)\n"
		"new_SbVec4ui32(SbVec4us v) -> SbVec4ui32\n"
		""},
	 { "SbVec4ui32_setValue", _wrap_SbVec4ui32_setValue, METH_VARARGS, "\n"
		"SbVec4ui32_setValue(SbVec4ui32 self, uint32_t const [4] v) -> SbVec4ui32\n"
		"SbVec4ui32_setValue(SbVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32\n"
		"SbVec4ui32_setValue(SbVec4ui32 self, SbVec4i32 v) -> SbVec4ui32\n"
		"SbVec4ui32_setValue(SbVec4ui32 self, SbVec4ub v) -> SbVec4ui32\n"
		"SbVec4ui32_setValue(SbVec4ui32 self, SbVec4us v) -> SbVec4ui32\n"
		""},
	 { "SbVec4ui32_getValue", _wrap_SbVec4ui32_getValue, METH_VARARGS, "\n"
		"SbVec4ui32_getValue(SbVec4ui32 self) -> uint32_t const\n"
		"SbVec4ui32_getValue(SbVec4ui32 self, uint32_t & x, uint32_t & y, uint32_t & z, uint32_t & w)\n"
		""},
	 { "SbVec4ui32_dot", _wrap_SbVec4ui32_dot, METH_VARARGS, "SbVec4ui32_dot(SbVec4ui32 self, SbVec4ui32 v) -> int32_t"},
	 { "SbVec4ui32_negate", _wrap_SbVec4ui32_negate, METH_O, "SbVec4ui32_negate(SbVec4ui32 self)"},
	 { "SbVec4ui32___imul__", _wrap_SbVec4ui32___imul__, METH_VARARGS, "\n"
		"SbVec4ui32___imul__(SbVec4ui32 self, int d) -> SbVec4ui32\n"
		"SbVec4ui32___imul__(SbVec4ui32 self, double d) -> SbVec4ui32\n"
		""},
	 { "SbVec4ui32___itruediv__", _wrap_SbVec4ui32___itruediv__, METH_VARARGS, "\n"
		"SbVec4ui32___itruediv__(SbVec4ui32 self, int d) -> SbVec4ui32\n"
		"SbVec4ui32___itruediv__(SbVec4ui32 self, double d) -> SbVec4ui32\n"
		""},
	 { "SbVec4ui32___iadd__", _wrap_SbVec4ui32___iadd__, METH_VARARGS, "SbVec4ui32___iadd__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"},
	 { "SbVec4ui32___isub__", _wrap_SbVec4ui32___isub__, METH_VARARGS, "SbVec4ui32___isub__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"},
	 { "SbVec4ui32___neg__", _wrap_SbVec4ui32___neg__, METH_O, "SbVec4ui32___neg__(SbVec4ui32 self) -> SbVec4ui32"},
	 { "delete_SbVec4ui32", _wrap_delete_SbVec4ui32, METH_O, "delete_SbVec4ui32(SbVec4ui32 self)"},
	 { "SbVec4ui32_swigregister", SbVec4ui32_swigregister, METH_O, NULL},
	 { "SbVec4ui32_swiginit", SbVec4ui32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4ui32", _wrap_new_SoSFVec4ui32, METH_NOARGS, "new_SoSFVec4ui32() -> SoSFVec4ui32"},
	 { "delete_SoSFVec4ui32", _wrap_delete_SoSFVec4ui32, METH_O, "delete_SoSFVec4ui32(SoSFVec4ui32 self)"},
	 { "SoSFVec4ui32_createInstance", _wrap_SoSFVec4ui32_createInstance, METH_NOARGS, "SoSFVec4ui32_createInstance() -> void *"},
	 { "SoSFVec4ui32_getClassTypeId", _wrap_SoSFVec4ui32_getClassTypeId, METH_NOARGS, "SoSFVec4ui32_getClassTypeId() -> SoType"},
	 { "SoSFVec4ui32_getTypeId", _wrap_SoSFVec4ui32_getTypeId, METH_O, "SoSFVec4ui32_getTypeId(SoSFVec4ui32 self) -> SoType"},
	 { "SoSFVec4ui32_copyFrom", _wrap_SoSFVec4ui32_copyFrom, METH_VARARGS, "SoSFVec4ui32_copyFrom(SoSFVec4ui32 self, SoField field)"},
	 { "SoSFVec4ui32_isSame", _wrap_SoSFVec4ui32_isSame, METH_VARARGS, "SoSFVec4ui32_isSame(SoSFVec4ui32 self, SoField field) -> SbBool"},
	 { "SoSFVec4ui32_getValue", _wrap_SoSFVec4ui32_getValue, METH_O, "SoSFVec4ui32_getValue(SoSFVec4ui32 self) -> SbVec4ui32"},
	 { "SoSFVec4ui32___eq__", _wrap_SoSFVec4ui32___eq__, METH_VARARGS, "SoSFVec4ui32___eq__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"},
	 { "SoSFVec4ui32___ne__", _wrap_SoSFVec4ui32___ne__, METH_VARARGS, "SoSFVec4ui32___ne__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"},
	 { "SoSFVec4ui32_initClass", _wrap_SoSFVec4ui32_initClass, METH_NOARGS, "SoSFVec4ui32_initClass()"},
	 { "SoSFVec4ui32_setValue", _wrap_SoSFVec4ui32_setValue, METH_VARARGS, "\n"
		"SoSFVec4ui32_setValue(SoSFVec4ui32 self, SbVec4ui32 newvalue)\n"
		"SoSFVec4ui32_setValue(SoSFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)\n"
		"SoSFVec4ui32_setValue(SoSFVec4ui32 self, uint32_t const [4] xyzw)\n"
		""},
	 { "SoSFVec4ui32_swigregister", SoSFVec4ui32_swigregister, METH_O, NULL},
	 { "SoSFVec4ui32_swiginit", SoSFVec4ui32_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4f", _wrap_new_SoSFVec4f, METH_NOARGS, "new_SoSFVec4f() -> SoSFVec4f"},
	 { "delete_SoSFVec4f", _wrap_delete_SoSFVec4f, METH_O, "delete_SoSFVec4f(SoSFVec4f self)"},
	 { "SoSFVec4f_createInstance", _wrap_SoSFVec4f_createInstance, METH_NOARGS, "SoSFVec4f_createInstance() -> void *"},
	 { "SoSFVec4f_getClassTypeId", _wrap_SoSFVec4f_getClassTypeId, METH_NOARGS, "SoSFVec4f_getClassTypeId() -> SoType"},
	 { "SoSFVec4f_getTypeId", _wrap_SoSFVec4f_getTypeId, METH_O, "SoSFVec4f_getTypeId(SoSFVec4f self) -> SoType"},
	 { "SoSFVec4f_copyFrom", _wrap_SoSFVec4f_copyFrom, METH_VARARGS, "SoSFVec4f_copyFrom(SoSFVec4f self, SoField field)"},
	 { "SoSFVec4f_isSame", _wrap_SoSFVec4f_isSame, METH_VARARGS, "SoSFVec4f_isSame(SoSFVec4f self, SoField field) -> SbBool"},
	 { "SoSFVec4f_getValue", _wrap_SoSFVec4f_getValue, METH_O, "SoSFVec4f_getValue(SoSFVec4f self) -> SbVec4f"},
	 { "SoSFVec4f___eq__", _wrap_SoSFVec4f___eq__, METH_VARARGS, "SoSFVec4f___eq__(SoSFVec4f self, SoSFVec4f field) -> int"},
	 { "SoSFVec4f___ne__", _wrap_SoSFVec4f___ne__, METH_VARARGS, "SoSFVec4f___ne__(SoSFVec4f self, SoSFVec4f field) -> int"},
	 { "SoSFVec4f_initClass", _wrap_SoSFVec4f_initClass, METH_NOARGS, "SoSFVec4f_initClass()"},
	 { "SoSFVec4f_setValue", _wrap_SoSFVec4f_setValue, METH_VARARGS, "\n"
		"SoSFVec4f_setValue(SoSFVec4f self, SbVec4f newvalue)\n"
		"SoSFVec4f_setValue(SoSFVec4f self, float x, float y, float z, float w)\n"
		"SoSFVec4f_setValue(SoSFVec4f self, float const [4] xyzw)\n"
		"SoSFVec4f_setValue(SoSFVec4f self, SoSFVec4f other)\n"
		""},
	 { "SoSFVec4f_swigregister", SoSFVec4f_swigregister, METH_O, NULL},
	 { "SoSFVec4f_swiginit", SoSFVec4f_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec4d", _wrap_new_SbVec4d, METH_VARARGS, "\n"
		"SbVec4d()\n"
		"SbVec4d(double const [4] v)\n"
		"SbVec4d(double x, double y, double z, double w)\n"
		"SbVec4d(SbVec4f v)\n"
		"SbVec4d(SbVec4b v)\n"
		"SbVec4d(SbVec4s v)\n"
		"new_SbVec4d(SbVec4i32 v) -> SbVec4d\n"
		""},
	 { "SbVec4d_setValue", _wrap_SbVec4d_setValue, METH_VARARGS, "\n"
		"SbVec4d_setValue(SbVec4d self, double const [4] v) -> SbVec4d\n"
		"SbVec4d_setValue(SbVec4d self, double x, double y, double z, double w) -> SbVec4d\n"
		"SbVec4d_setValue(SbVec4d self, SbVec4f v) -> SbVec4d\n"
		"SbVec4d_setValue(SbVec4d self, SbVec4b v) -> SbVec4d\n"
		"SbVec4d_setValue(SbVec4d self, SbVec4s v) -> SbVec4d\n"
		"SbVec4d_setValue(SbVec4d self, SbVec4i32 v) -> SbVec4d\n"
		""},
	 { "SbVec4d_getValue", _wrap_SbVec4d_getValue, METH_O, "SbVec4d_getValue(SbVec4d self) -> double const *"},
	 { "SbVec4d_dot", _wrap_SbVec4d_dot, METH_VARARGS, "SbVec4d_dot(SbVec4d self, SbVec4d v) -> double"},
	 { "SbVec4d_equals", _wrap_SbVec4d_equals, METH_VARARGS, "SbVec4d_equals(SbVec4d self, SbVec4d v, double tolerance) -> SbBool"},
	 { "SbVec4d_getReal", _wrap_SbVec4d_getReal, METH_VARARGS, "SbVec4d_getReal(SbVec4d self, SbVec3d v)"},
	 { "SbVec4d_length", _wrap_SbVec4d_length, METH_O, "SbVec4d_length(SbVec4d self) -> double"},
	 { "SbVec4d_sqrLength", _wrap_SbVec4d_sqrLength, METH_O, "SbVec4d_sqrLength(SbVec4d self) -> double"},
	 { "SbVec4d_negate", _wrap_SbVec4d_negate, METH_O, "SbVec4d_negate(SbVec4d self)"},
	 { "SbVec4d_normalize", _wrap_SbVec4d_normalize, METH_O, "SbVec4d_normalize(SbVec4d self) -> double"},
	 { "SbVec4d___imul__", _wrap_SbVec4d___imul__, METH_VARARGS, "SbVec4d___imul__(SbVec4d self, double d) -> SbVec4d"},
	 { "SbVec4d___itruediv__", _wrap_SbVec4d___itruediv__, METH_VARARGS, "SbVec4d___itruediv__(SbVec4d self, double d) -> SbVec4d"},
	 { "SbVec4d___iadd__", _wrap_SbVec4d___iadd__, METH_VARARGS, "SbVec4d___iadd__(SbVec4d self, SbVec4d v) -> SbVec4d"},
	 { "SbVec4d___isub__", _wrap_SbVec4d___isub__, METH_VARARGS, "SbVec4d___isub__(SbVec4d self, SbVec4d v) -> SbVec4d"},
	 { "SbVec4d___neg__", _wrap_SbVec4d___neg__, METH_O, "SbVec4d___neg__(SbVec4d self) -> SbVec4d"},
	 { "SbVec4d_output", _wrap_SbVec4d_output, METH_VARARGS, "SbVec4d_output(SbVec4d self, FILE * fp)"},
	 { "SbVec4d___add__", _wrap_SbVec4d___add__, METH_VARARGS, "SbVec4d___add__(SbVec4d self, SbVec4d u) -> SbVec4d"},
	 { "SbVec4d___sub__", _wrap_SbVec4d___sub__, METH_VARARGS, "SbVec4d___sub__(SbVec4d self, SbVec4d u) -> SbVec4d"},
	 { "SbVec4d___mul__", _wrap_SbVec4d___mul__, METH_VARARGS, "\n"
		"SbVec4d___mul__(SbVec4d self, double const d) -> SbVec4d\n"
		"SbVec4d___mul__(SbVec4d self, SbDPMatrix m) -> SbVec4d\n"
		""},
	 { "SbVec4d___rmul__", _wrap_SbVec4d___rmul__, METH_VARARGS, "SbVec4d___rmul__(SbVec4d self, double const d) -> SbVec4d"},
	 { "SbVec4d___div__", _wrap_SbVec4d___div__, METH_VARARGS, "SbVec4d___div__(SbVec4d self, double const d) -> SbVec4d"},
	 { "SbVec4d___truediv__", _wrap_SbVec4d___truediv__, METH_VARARGS, "SbVec4d___truediv__(SbVec4d self, double const d) -> SbVec4d"},
	 { "SbVec4d___eq__", _wrap_SbVec4d___eq__, METH_VARARGS, "SbVec4d___eq__(SbVec4d self, SbVec4d u) -> int"},
	 { "SbVec4d___nq__", _wrap_SbVec4d___nq__, METH_VARARGS, "SbVec4d___nq__(SbVec4d self, SbVec4d u) -> int"},
	 { "SbVec4d___getitem__", _wrap_SbVec4d___getitem__, METH_VARARGS, "SbVec4d___getitem__(SbVec4d self, int i) -> double"},
	 { "SbVec4d___setitem__", _wrap_SbVec4d___setitem__, METH_VARARGS, "SbVec4d___setitem__(SbVec4d self, int i, double value)"},
	 { "delete_SbVec4d", _wrap_delete_SbVec4d, METH_O, "delete_SbVec4d(SbVec4d self)"},
	 { "SbVec4d_swigregister", SbVec4d_swigregister, METH_O, NULL},
	 { "SbVec4d_swiginit", SbVec4d_swiginit, METH_VARARGS, NULL},
	 { "new_SoSFVec4d", _wrap_new_SoSFVec4d, METH_NOARGS, "new_SoSFVec4d() -> SoSFVec4d"},
	 { "delete_SoSFVec4d", _wrap_delete_SoSFVec4d, METH_O, "delete_SoSFVec4d(SoSFVec4d self)"},
	 { "SoSFVec4d_createInstance", _wrap_SoSFVec4d_createInstance, METH_NOARGS, "SoSFVec4d_createInstance() -> void *"},
	 { "SoSFVec4d_getClassTypeId", _wrap_SoSFVec4d_getClassTypeId, METH_NOARGS, "SoSFVec4d_getClassTypeId() -> SoType"},
	 { "SoSFVec4d_getTypeId", _wrap_SoSFVec4d_getTypeId, METH_O, "SoSFVec4d_getTypeId(SoSFVec4d self) -> SoType"},
	 { "SoSFVec4d_copyFrom", _wrap_SoSFVec4d_copyFrom, METH_VARARGS, "SoSFVec4d_copyFrom(SoSFVec4d self, SoField field)"},
	 { "SoSFVec4d_isSame", _wrap_SoSFVec4d_isSame, METH_VARARGS, "SoSFVec4d_isSame(SoSFVec4d self, SoField field) -> SbBool"},
	 { "SoSFVec4d_getValue", _wrap_SoSFVec4d_getValue, METH_O, "SoSFVec4d_getValue(SoSFVec4d self) -> SbVec4d"},
	 { "SoSFVec4d___eq__", _wrap_SoSFVec4d___eq__, METH_VARARGS, "SoSFVec4d___eq__(SoSFVec4d self, SoSFVec4d field) -> int"},
	 { "SoSFVec4d___ne__", _wrap_SoSFVec4d___ne__, METH_VARARGS, "SoSFVec4d___ne__(SoSFVec4d self, SoSFVec4d field) -> int"},
	 { "SoSFVec4d_initClass", _wrap_SoSFVec4d_initClass, METH_NOARGS, "SoSFVec4d_initClass()"},
	 { "SoSFVec4d_setValue", _wrap_SoSFVec4d_setValue, METH_VARARGS, "\n"
		"SoSFVec4d_setValue(SoSFVec4d self, SbVec4d newvalue)\n"
		"SoSFVec4d_setValue(SoSFVec4d self, double x, double y, double z, double w)\n"
		"SoSFVec4d_setValue(SoSFVec4d self, double const [4] xyzw)\n"
		""},
	 { "SoSFVec4d_swigregister", SoSFVec4d_swigregister, METH_O, NULL},
	 { "SoSFVec4d_swiginit", SoSFVec4d_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFColor", _wrap_new_SoMFColor, METH_NOARGS, "new_SoMFColor() -> SoMFColor"},
	 { "delete_SoMFColor", _wrap_delete_SoMFColor, METH_O, "delete_SoMFColor(SoMFColor self)"},
	 { "SoMFColor_createInstance", _wrap_SoMFColor_createInstance, METH_NOARGS, "SoMFColor_createInstance() -> void *"},
	 { "SoMFColor_getClassTypeId", _wrap_SoMFColor_getClassTypeId, METH_NOARGS, "SoMFColor_getClassTypeId() -> SoType"},
	 { "SoMFColor_getTypeId", _wrap_SoMFColor_getTypeId, METH_O, "SoMFColor_getTypeId(SoMFColor self) -> SoType"},
	 { "SoMFColor_copyFrom", _wrap_SoMFColor_copyFrom, METH_VARARGS, "SoMFColor_copyFrom(SoMFColor self, SoField field)"},
	 { "SoMFColor_isSame", _wrap_SoMFColor_isSame, METH_VARARGS, "SoMFColor_isSame(SoMFColor self, SoField field) -> SbBool"},
	 { "SoMFColor_find", _wrap_SoMFColor_find, METH_VARARGS, "SoMFColor_find(SoMFColor self, SbColor value, SbBool addifnotfound=0) -> int"},
	 { "SoMFColor___eq__", _wrap_SoMFColor___eq__, METH_VARARGS, "SoMFColor___eq__(SoMFColor self, SoMFColor field) -> SbBool"},
	 { "SoMFColor___ne__", _wrap_SoMFColor___ne__, METH_VARARGS, "SoMFColor___ne__(SoMFColor self, SoMFColor field) -> SbBool"},
	 { "SoMFColor_startEditing", _wrap_SoMFColor_startEditing, METH_O, "SoMFColor_startEditing(SoMFColor self) -> SbColor"},
	 { "SoMFColor_finishEditing", _wrap_SoMFColor_finishEditing, METH_O, "SoMFColor_finishEditing(SoMFColor self)"},
	 { "SoMFColor_setValuesPointer", _wrap_SoMFColor_setValuesPointer, METH_VARARGS, "\n"
		"SoMFColor_setValuesPointer(SoMFColor self, int const num, float const * userdata)\n"
		"SoMFColor_setValuesPointer(SoMFColor self, int const num, float * userdata)\n"
		"SoMFColor_setValuesPointer(SoMFColor self, int const num, SbColor userdata)\n"
		"SoMFColor_setValuesPointer(SoMFColor self, int const num, SbColor userdata)\n"
		""},
	 { "SoMFColor_initClass", _wrap_SoMFColor_initClass, METH_NOARGS, "SoMFColor_initClass()"},
	 { "SoMFColor_setValues", _wrap_SoMFColor_setValues, METH_VARARGS, "SoMFColor_setValues(SoMFColor self, int start, int num, float const [][3] rgb)"},
	 { "SoMFColor_setHSVValues", _wrap_SoMFColor_setHSVValues, METH_VARARGS, "SoMFColor_setHSVValues(SoMFColor self, int start, int num, float const [][3] hsv)"},
	 { "SoMFColor_setHSVValue", _wrap_SoMFColor_setHSVValue, METH_VARARGS, "\n"
		"SoMFColor_setHSVValue(SoMFColor self, float h, float s, float v)\n"
		"SoMFColor_setHSVValue(SoMFColor self, float const [3] hsv)\n"
		""},
	 { "SoMFColor_set1Value", _wrap_SoMFColor_set1Value, METH_VARARGS, "\n"
		"SoMFColor_set1Value(SoMFColor self, int const idx, SbColor value)\n"
		"SoMFColor_set1Value(SoMFColor self, int idx, SbVec3f vec)\n"
		"SoMFColor_set1Value(SoMFColor self, int idx, float r, float g, float b)\n"
		"SoMFColor_set1Value(SoMFColor self, int idx, float const [3] rgb)\n"
		""},
	 { "SoMFColor_set1HSVValue", _wrap_SoMFColor_set1HSVValue, METH_VARARGS, "\n"
		"SoMFColor_set1HSVValue(SoMFColor self, int idx, float h, float s, float v)\n"
		"SoMFColor_set1HSVValue(SoMFColor self, int idx, float const [3] hsv)\n"
		""},
	 { "SoMFColor___getitem__", _wrap_SoMFColor___getitem__, METH_VARARGS, "SoMFColor___getitem__(SoMFColor self, int i) -> SbColor"},
	 { "SoMFColor___setitem__", _wrap_SoMFColor___setitem__, METH_VARARGS, "\n"
		"SoMFColor___setitem__(SoMFColor self, int i, SbColor value)\n"
		"SoMFColor___setitem__(SoMFColor self, int i, float const [3] rgb)\n"
		""},
	 { "SoMFColor_setValue", _wrap_SoMFColor_setValue, METH_VARARGS, "\n"
		"SoMFColor_setValue(SoMFColor self, SbColor value)\n"
		"SoMFColor_setValue(SoMFColor self, SbVec3f vec)\n"
		"SoMFColor_setValue(SoMFColor self, float r, float g, float b)\n"
		"SoMFColor_setValue(SoMFColor self, float const [3] rgb)\n"
		"SoMFColor_setValue(SoMFColor self, SoMFColor other)\n"
		""},
	 { "SoMFColor_getValues", _wrap_SoMFColor_getValues, METH_VARARGS, "SoMFColor_getValues(SoMFColor self, int i=0) -> SbColor"},
	 { "SoMFColor_swigregister", SoMFColor_swigregister, METH_O, NULL},
	 { "SoMFColor_swiginit", SoMFColor_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFColorRGBA", _wrap_new_SoMFColorRGBA, METH_NOARGS, "new_SoMFColorRGBA() -> SoMFColorRGBA"},
	 { "delete_SoMFColorRGBA", _wrap_delete_SoMFColorRGBA, METH_O, "delete_SoMFColorRGBA(SoMFColorRGBA self)"},
	 { "SoMFColorRGBA_createInstance", _wrap_SoMFColorRGBA_createInstance, METH_NOARGS, "SoMFColorRGBA_createInstance() -> void *"},
	 { "SoMFColorRGBA_getClassTypeId", _wrap_SoMFColorRGBA_getClassTypeId, METH_NOARGS, "SoMFColorRGBA_getClassTypeId() -> SoType"},
	 { "SoMFColorRGBA_getTypeId", _wrap_SoMFColorRGBA_getTypeId, METH_O, "SoMFColorRGBA_getTypeId(SoMFColorRGBA self) -> SoType"},
	 { "SoMFColorRGBA_copyFrom", _wrap_SoMFColorRGBA_copyFrom, METH_VARARGS, "SoMFColorRGBA_copyFrom(SoMFColorRGBA self, SoField field)"},
	 { "SoMFColorRGBA_isSame", _wrap_SoMFColorRGBA_isSame, METH_VARARGS, "SoMFColorRGBA_isSame(SoMFColorRGBA self, SoField field) -> SbBool"},
	 { "SoMFColorRGBA_getValues", _wrap_SoMFColorRGBA_getValues, METH_VARARGS, "SoMFColorRGBA_getValues(SoMFColorRGBA self, int const start) -> SbColor4f"},
	 { "SoMFColorRGBA_find", _wrap_SoMFColorRGBA_find, METH_VARARGS, "SoMFColorRGBA_find(SoMFColorRGBA self, SbColor4f value, SbBool addifnotfound=0) -> int"},
	 { "SoMFColorRGBA___eq__", _wrap_SoMFColorRGBA___eq__, METH_VARARGS, "SoMFColorRGBA___eq__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"},
	 { "SoMFColorRGBA___ne__", _wrap_SoMFColorRGBA___ne__, METH_VARARGS, "SoMFColorRGBA___ne__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"},
	 { "SoMFColorRGBA_startEditing", _wrap_SoMFColorRGBA_startEditing, METH_O, "SoMFColorRGBA_startEditing(SoMFColorRGBA self) -> SbColor4f"},
	 { "SoMFColorRGBA_finishEditing", _wrap_SoMFColorRGBA_finishEditing, METH_O, "SoMFColorRGBA_finishEditing(SoMFColorRGBA self)"},
	 { "SoMFColorRGBA_setValuesPointer", _wrap_SoMFColorRGBA_setValuesPointer, METH_VARARGS, "\n"
		"SoMFColorRGBA_setValuesPointer(SoMFColorRGBA self, int const num, float const * userdata)\n"
		"SoMFColorRGBA_setValuesPointer(SoMFColorRGBA self, int const num, float * userdata)\n"
		"SoMFColorRGBA_setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)\n"
		"SoMFColorRGBA_setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)\n"
		""},
	 { "SoMFColorRGBA_initClass", _wrap_SoMFColorRGBA_initClass, METH_NOARGS, "SoMFColorRGBA_initClass()"},
	 { "SoMFColorRGBA_setValues", _wrap_SoMFColorRGBA_setValues, METH_VARARGS, "\n"
		"SoMFColorRGBA_setValues(SoMFColorRGBA self, int const start, int const num, SbColor4f newvals)\n"
		"SoMFColorRGBA_setValues(SoMFColorRGBA self, int start, int num, float const [][4] rgba)\n"
		""},
	 { "SoMFColorRGBA_setHSVValues", _wrap_SoMFColorRGBA_setHSVValues, METH_VARARGS, "SoMFColorRGBA_setHSVValues(SoMFColorRGBA self, int start, int num, float const [][4] hsv)"},
	 { "SoMFColorRGBA_setValue", _wrap_SoMFColorRGBA_setValue, METH_VARARGS, "\n"
		"SoMFColorRGBA_setValue(SoMFColorRGBA self, SbColor4f value)\n"
		"SoMFColorRGBA_setValue(SoMFColorRGBA self, SbVec4f vec)\n"
		"SoMFColorRGBA_setValue(SoMFColorRGBA self, float r, float g, float b, float a)\n"
		"SoMFColorRGBA_setValue(SoMFColorRGBA self, float const [4] rgba)\n"
		""},
	 { "SoMFColorRGBA_setHSVValue", _wrap_SoMFColorRGBA_setHSVValue, METH_VARARGS, "\n"
		"SoMFColorRGBA_setHSVValue(SoMFColorRGBA self, float h, float s, float v, float a)\n"
		"SoMFColorRGBA_setHSVValue(SoMFColorRGBA self, float const [4] hsva)\n"
		""},
	 { "SoMFColorRGBA_set1Value", _wrap_SoMFColorRGBA_set1Value, METH_VARARGS, "\n"
		"SoMFColorRGBA_set1Value(SoMFColorRGBA self, int const idx, SbColor4f value)\n"
		"SoMFColorRGBA_set1Value(SoMFColorRGBA self, int idx, SbVec4f vec)\n"
		"SoMFColorRGBA_set1Value(SoMFColorRGBA self, int idx, float r, float g, float b, float a)\n"
		"SoMFColorRGBA_set1Value(SoMFColorRGBA self, int idx, float const [4] rgba)\n"
		""},
	 { "SoMFColorRGBA_set1HSVValue", _wrap_SoMFColorRGBA_set1HSVValue, METH_VARARGS, "\n"
		"SoMFColorRGBA_set1HSVValue(SoMFColorRGBA self, int idx, float h, float s, float v, float a)\n"
		"SoMFColorRGBA_set1HSVValue(SoMFColorRGBA self, int idx, float const [4] hsva)\n"
		""},
	 { "SoMFColorRGBA_swigregister", SoMFColorRGBA_swigregister, METH_O, NULL},
	 { "SoMFColorRGBA_swiginit", SoMFColorRGBA_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFDouble", _wrap_new_SoMFDouble, METH_NOARGS, "new_SoMFDouble() -> SoMFDouble"},
	 { "delete_SoMFDouble", _wrap_delete_SoMFDouble, METH_O, "delete_SoMFDouble(SoMFDouble self)"},
	 { "SoMFDouble_createInstance", _wrap_SoMFDouble_createInstance, METH_NOARGS, "SoMFDouble_createInstance() -> void *"},
	 { "SoMFDouble_getClassTypeId", _wrap_SoMFDouble_getClassTypeId, METH_NOARGS, "SoMFDouble_getClassTypeId() -> SoType"},
	 { "SoMFDouble_getTypeId", _wrap_SoMFDouble_getTypeId, METH_O, "SoMFDouble_getTypeId(SoMFDouble self) -> SoType"},
	 { "SoMFDouble_copyFrom", _wrap_SoMFDouble_copyFrom, METH_VARARGS, "SoMFDouble_copyFrom(SoMFDouble self, SoField field)"},
	 { "SoMFDouble_isSame", _wrap_SoMFDouble_isSame, METH_VARARGS, "SoMFDouble_isSame(SoMFDouble self, SoField field) -> SbBool"},
	 { "SoMFDouble_getValues", _wrap_SoMFDouble_getValues, METH_VARARGS, "SoMFDouble_getValues(SoMFDouble self, int const start) -> double const *"},
	 { "SoMFDouble_find", _wrap_SoMFDouble_find, METH_VARARGS, "SoMFDouble_find(SoMFDouble self, double value, SbBool addifnotfound=0) -> int"},
	 { "SoMFDouble_setValues", _wrap_SoMFDouble_setValues, METH_VARARGS, "SoMFDouble_setValues(SoMFDouble self, int const start, int const num, double const * newvals)"},
	 { "SoMFDouble_set1Value", _wrap_SoMFDouble_set1Value, METH_VARARGS, "SoMFDouble_set1Value(SoMFDouble self, int const idx, double value)"},
	 { "SoMFDouble_setValue", _wrap_SoMFDouble_setValue, METH_VARARGS, "SoMFDouble_setValue(SoMFDouble self, double value)"},
	 { "SoMFDouble___eq__", _wrap_SoMFDouble___eq__, METH_VARARGS, "SoMFDouble___eq__(SoMFDouble self, SoMFDouble field) -> SbBool"},
	 { "SoMFDouble___ne__", _wrap_SoMFDouble___ne__, METH_VARARGS, "SoMFDouble___ne__(SoMFDouble self, SoMFDouble field) -> SbBool"},
	 { "SoMFDouble_startEditing", _wrap_SoMFDouble_startEditing, METH_O, "SoMFDouble_startEditing(SoMFDouble self) -> double *"},
	 { "SoMFDouble_finishEditing", _wrap_SoMFDouble_finishEditing, METH_O, "SoMFDouble_finishEditing(SoMFDouble self)"},
	 { "SoMFDouble_setValuesPointer", _wrap_SoMFDouble_setValuesPointer, METH_VARARGS, "\n"
		"SoMFDouble_setValuesPointer(SoMFDouble self, int const num, double const * userdata)\n"
		"SoMFDouble_setValuesPointer(SoMFDouble self, int const num, double * userdata)\n"
		""},
	 { "SoMFDouble_initClass", _wrap_SoMFDouble_initClass, METH_NOARGS, "SoMFDouble_initClass()"},
	 { "SoMFDouble_swigregister", SoMFDouble_swigregister, METH_O, NULL},
	 { "SoMFDouble_swiginit", SoMFDouble_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFEngine", _wrap_new_SoMFEngine, METH_NOARGS, "new_SoMFEngine() -> SoMFEngine"},
	 { "delete_SoMFEngine", _wrap_delete_SoMFEngine, METH_O, "delete_SoMFEngine(SoMFEngine self)"},
	 { "SoMFEngine_createInstance", _wrap_SoMFEngine_createInstance, METH_NOARGS, "SoMFEngine_createInstance() -> void *"},
	 { "SoMFEngine_getClassTypeId", _wrap_SoMFEngine_getClassTypeId, METH_NOARGS, "SoMFEngine_getClassTypeId() -> SoType"},
	 { "SoMFEngine_getTypeId", _wrap_SoMFEngine_getTypeId, METH_O, "SoMFEngine_getTypeId(SoMFEngine self) -> SoType"},
	 { "SoMFEngine_copyFrom", _wrap_SoMFEngine_copyFrom, METH_VARARGS, "SoMFEngine_copyFrom(SoMFEngine self, SoField field)"},
	 { "SoMFEngine_isSame", _wrap_SoMFEngine_isSame, METH_VARARGS, "SoMFEngine_isSame(SoMFEngine self, SoField field) -> SbBool"},
	 { "SoMFEngine_find", _wrap_SoMFEngine_find, METH_VARARGS, "SoMFEngine_find(SoMFEngine self, SoEngine value, SbBool addifnotfound=0) -> int"},
	 { "SoMFEngine_setValues", _wrap_SoMFEngine_setValues, METH_VARARGS, "SoMFEngine_setValues(SoMFEngine self, int const start, int const num, SoEngine const ** newvals)"},
	 { "SoMFEngine_set1Value", _wrap_SoMFEngine_set1Value, METH_VARARGS, "SoMFEngine_set1Value(SoMFEngine self, int const idx, SoEngine value)"},
	 { "SoMFEngine___eq__", _wrap_SoMFEngine___eq__, METH_VARARGS, "SoMFEngine___eq__(SoMFEngine self, SoMFEngine field) -> SbBool"},
	 { "SoMFEngine___ne__", _wrap_SoMFEngine___ne__, METH_VARARGS, "SoMFEngine___ne__(SoMFEngine self, SoMFEngine field) -> SbBool"},
	 { "SoMFEngine_startEditing", _wrap_SoMFEngine_startEditing, METH_O, "SoMFEngine_startEditing(SoMFEngine self) -> SoEngine **"},
	 { "SoMFEngine_finishEditing", _wrap_SoMFEngine_finishEditing, METH_O, "SoMFEngine_finishEditing(SoMFEngine self)"},
	 { "SoMFEngine_initClass", _wrap_SoMFEngine_initClass, METH_NOARGS, "SoMFEngine_initClass()"},
	 { "SoMFEngine_fixCopy", _wrap_SoMFEngine_fixCopy, METH_VARARGS, "SoMFEngine_fixCopy(SoMFEngine self, SbBool copyconnections)"},
	 { "SoMFEngine_referencesCopy", _wrap_SoMFEngine_referencesCopy, METH_O, "SoMFEngine_referencesCopy(SoMFEngine self) -> SbBool"},
	 { "SoMFEngine_deleteValues", _wrap_SoMFEngine_deleteValues, METH_VARARGS, "SoMFEngine_deleteValues(SoMFEngine self, int start, int num=-1)"},
	 { "SoMFEngine_insertSpace", _wrap_SoMFEngine_insertSpace, METH_VARARGS, "SoMFEngine_insertSpace(SoMFEngine self, int start, int num)"},
	 { "SoMFEngine___getitem__", _wrap_SoMFEngine___getitem__, METH_VARARGS, "SoMFEngine___getitem__(SoMFEngine self, int i) -> SoEngine"},
	 { "SoMFEngine___setitem__", _wrap_SoMFEngine___setitem__, METH_VARARGS, "SoMFEngine___setitem__(SoMFEngine self, int i, SoEngine value)"},
	 { "SoMFEngine_setValue", _wrap_SoMFEngine_setValue, METH_VARARGS, "\n"
		"SoMFEngine_setValue(SoMFEngine self, SoEngine value)\n"
		"SoMFEngine_setValue(SoMFEngine self, SoMFEngine other)\n"
		""},
	 { "SoMFEngine_getValues", _wrap_SoMFEngine_getValues, METH_VARARGS, "SoMFEngine_getValues(SoMFEngine self, int i=0) -> SoEngine"},
	 { "SoMFEngine_swigregister", SoMFEngine_swigregister, METH_O, NULL},
	 { "SoMFEngine_swiginit", SoMFEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFBitMask", _wrap_new_SoMFBitMask, METH_NOARGS, "new_SoMFBitMask() -> SoMFBitMask"},
	 { "delete_SoMFBitMask", _wrap_delete_SoMFBitMask, METH_O, "delete_SoMFBitMask(SoMFBitMask self)"},
	 { "SoMFBitMask_createInstance", _wrap_SoMFBitMask_createInstance, METH_NOARGS, "SoMFBitMask_createInstance() -> void *"},
	 { "SoMFBitMask_getClassTypeId", _wrap_SoMFBitMask_getClassTypeId, METH_NOARGS, "SoMFBitMask_getClassTypeId() -> SoType"},
	 { "SoMFBitMask_getTypeId", _wrap_SoMFBitMask_getTypeId, METH_O, "SoMFBitMask_getTypeId(SoMFBitMask self) -> SoType"},
	 { "SoMFBitMask_copyFrom", _wrap_SoMFBitMask_copyFrom, METH_VARARGS, "SoMFBitMask_copyFrom(SoMFBitMask self, SoField field)"},
	 { "SoMFBitMask_isSame", _wrap_SoMFBitMask_isSame, METH_VARARGS, "SoMFBitMask_isSame(SoMFBitMask self, SoField field) -> SbBool"},
	 { "SoMFBitMask_initClass", _wrap_SoMFBitMask_initClass, METH_NOARGS, "SoMFBitMask_initClass()"},
	 { "SoMFBitMask_swigregister", SoMFBitMask_swigregister, METH_O, NULL},
	 { "SoMFBitMask_swiginit", SoMFBitMask_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFInt32", _wrap_new_SoMFInt32, METH_NOARGS, "new_SoMFInt32() -> SoMFInt32"},
	 { "delete_SoMFInt32", _wrap_delete_SoMFInt32, METH_O, "delete_SoMFInt32(SoMFInt32 self)"},
	 { "SoMFInt32_createInstance", _wrap_SoMFInt32_createInstance, METH_NOARGS, "SoMFInt32_createInstance() -> void *"},
	 { "SoMFInt32_getClassTypeId", _wrap_SoMFInt32_getClassTypeId, METH_NOARGS, "SoMFInt32_getClassTypeId() -> SoType"},
	 { "SoMFInt32_getTypeId", _wrap_SoMFInt32_getTypeId, METH_O, "SoMFInt32_getTypeId(SoMFInt32 self) -> SoType"},
	 { "SoMFInt32_copyFrom", _wrap_SoMFInt32_copyFrom, METH_VARARGS, "SoMFInt32_copyFrom(SoMFInt32 self, SoField field)"},
	 { "SoMFInt32_isSame", _wrap_SoMFInt32_isSame, METH_VARARGS, "SoMFInt32_isSame(SoMFInt32 self, SoField field) -> SbBool"},
	 { "SoMFInt32_find", _wrap_SoMFInt32_find, METH_VARARGS, "SoMFInt32_find(SoMFInt32 self, int32_t value, SbBool addifnotfound=0) -> int"},
	 { "SoMFInt32_setValues", _wrap_SoMFInt32_setValues, METH_VARARGS, "SoMFInt32_setValues(SoMFInt32 self, int const start, int const num, int32_t const * newvals)"},
	 { "SoMFInt32_set1Value", _wrap_SoMFInt32_set1Value, METH_VARARGS, "SoMFInt32_set1Value(SoMFInt32 self, int const idx, int32_t value)"},
	 { "SoMFInt32___eq__", _wrap_SoMFInt32___eq__, METH_VARARGS, "SoMFInt32___eq__(SoMFInt32 self, SoMFInt32 field) -> SbBool"},
	 { "SoMFInt32___ne__", _wrap_SoMFInt32___ne__, METH_VARARGS, "SoMFInt32___ne__(SoMFInt32 self, SoMFInt32 field) -> SbBool"},
	 { "SoMFInt32_startEditing", _wrap_SoMFInt32_startEditing, METH_O, "SoMFInt32_startEditing(SoMFInt32 self) -> int32_t *"},
	 { "SoMFInt32_finishEditing", _wrap_SoMFInt32_finishEditing, METH_O, "SoMFInt32_finishEditing(SoMFInt32 self)"},
	 { "SoMFInt32_setValuesPointer", _wrap_SoMFInt32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFInt32_setValuesPointer(SoMFInt32 self, int const num, int32_t const * userdata)\n"
		"SoMFInt32_setValuesPointer(SoMFInt32 self, int const num, int32_t * userdata)\n"
		""},
	 { "SoMFInt32_initClass", _wrap_SoMFInt32_initClass, METH_NOARGS, "SoMFInt32_initClass()"},
	 { "SoMFInt32___getitem__", _wrap_SoMFInt32___getitem__, METH_VARARGS, "SoMFInt32___getitem__(SoMFInt32 self, int i) -> int32_t const"},
	 { "SoMFInt32___setitem__", _wrap_SoMFInt32___setitem__, METH_VARARGS, "SoMFInt32___setitem__(SoMFInt32 self, int i, int32_t value)"},
	 { "SoMFInt32_setValue", _wrap_SoMFInt32_setValue, METH_VARARGS, "\n"
		"SoMFInt32_setValue(SoMFInt32 self, int32_t value)\n"
		"SoMFInt32_setValue(SoMFInt32 self, SoMFInt32 other)\n"
		""},
	 { "SoMFInt32_getValues", _wrap_SoMFInt32_getValues, METH_VARARGS, "SoMFInt32_getValues(SoMFInt32 self, int32_t i=0) -> int32_t const"},
	 { "SoMFInt32_swigregister", SoMFInt32_swigregister, METH_O, NULL},
	 { "SoMFInt32_swiginit", SoMFInt32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFNode", _wrap_new_SoMFNode, METH_NOARGS, "new_SoMFNode() -> SoMFNode"},
	 { "delete_SoMFNode", _wrap_delete_SoMFNode, METH_O, "delete_SoMFNode(SoMFNode self)"},
	 { "SoMFNode_createInstance", _wrap_SoMFNode_createInstance, METH_NOARGS, "SoMFNode_createInstance() -> void *"},
	 { "SoMFNode_getClassTypeId", _wrap_SoMFNode_getClassTypeId, METH_NOARGS, "SoMFNode_getClassTypeId() -> SoType"},
	 { "SoMFNode_getTypeId", _wrap_SoMFNode_getTypeId, METH_O, "SoMFNode_getTypeId(SoMFNode self) -> SoType"},
	 { "SoMFNode_copyFrom", _wrap_SoMFNode_copyFrom, METH_VARARGS, "SoMFNode_copyFrom(SoMFNode self, SoField field)"},
	 { "SoMFNode_isSame", _wrap_SoMFNode_isSame, METH_VARARGS, "SoMFNode_isSame(SoMFNode self, SoField field) -> SbBool"},
	 { "SoMFNode_find", _wrap_SoMFNode_find, METH_VARARGS, "SoMFNode_find(SoMFNode self, SoNode value, SbBool addifnotfound=0) -> int"},
	 { "SoMFNode_setValues", _wrap_SoMFNode_setValues, METH_VARARGS, "SoMFNode_setValues(SoMFNode self, int const start, int const num, SoNode const ** newvals)"},
	 { "SoMFNode_set1Value", _wrap_SoMFNode_set1Value, METH_VARARGS, "SoMFNode_set1Value(SoMFNode self, int const idx, SoNode value)"},
	 { "SoMFNode___eq__", _wrap_SoMFNode___eq__, METH_VARARGS, "SoMFNode___eq__(SoMFNode self, SoMFNode field) -> SbBool"},
	 { "SoMFNode___ne__", _wrap_SoMFNode___ne__, METH_VARARGS, "SoMFNode___ne__(SoMFNode self, SoMFNode field) -> SbBool"},
	 { "SoMFNode_startEditing", _wrap_SoMFNode_startEditing, METH_O, "SoMFNode_startEditing(SoMFNode self) -> SoNode **"},
	 { "SoMFNode_finishEditing", _wrap_SoMFNode_finishEditing, METH_O, "SoMFNode_finishEditing(SoMFNode self)"},
	 { "SoMFNode_initClass", _wrap_SoMFNode_initClass, METH_NOARGS, "SoMFNode_initClass()"},
	 { "SoMFNode_fixCopy", _wrap_SoMFNode_fixCopy, METH_VARARGS, "SoMFNode_fixCopy(SoMFNode self, SbBool copyconnections)"},
	 { "SoMFNode_referencesCopy", _wrap_SoMFNode_referencesCopy, METH_O, "SoMFNode_referencesCopy(SoMFNode self) -> SbBool"},
	 { "SoMFNode_addNode", _wrap_SoMFNode_addNode, METH_VARARGS, "SoMFNode_addNode(SoMFNode self, SoNode node)"},
	 { "SoMFNode_insertNode", _wrap_SoMFNode_insertNode, METH_VARARGS, "SoMFNode_insertNode(SoMFNode self, SoNode node, int idx)"},
	 { "SoMFNode_getNode", _wrap_SoMFNode_getNode, METH_VARARGS, "SoMFNode_getNode(SoMFNode self, int idx) -> SoNode"},
	 { "SoMFNode_findNode", _wrap_SoMFNode_findNode, METH_VARARGS, "SoMFNode_findNode(SoMFNode self, SoNode node) -> int"},
	 { "SoMFNode_getNumNodes", _wrap_SoMFNode_getNumNodes, METH_O, "SoMFNode_getNumNodes(SoMFNode self) -> int"},
	 { "SoMFNode_removeNode", _wrap_SoMFNode_removeNode, METH_VARARGS, "\n"
		"SoMFNode_removeNode(SoMFNode self, int index)\n"
		"SoMFNode_removeNode(SoMFNode self, SoNode node)\n"
		""},
	 { "SoMFNode_removeAllNodes", _wrap_SoMFNode_removeAllNodes, METH_O, "SoMFNode_removeAllNodes(SoMFNode self)"},
	 { "SoMFNode_replaceNode", _wrap_SoMFNode_replaceNode, METH_VARARGS, "\n"
		"SoMFNode_replaceNode(SoMFNode self, int idx, SoNode newnode)\n"
		"SoMFNode_replaceNode(SoMFNode self, SoNode oldnode, SoNode newnode)\n"
		""},
	 { "SoMFNode_deleteValues", _wrap_SoMFNode_deleteValues, METH_VARARGS, "SoMFNode_deleteValues(SoMFNode self, int start, int num=-1)"},
	 { "SoMFNode_insertSpace", _wrap_SoMFNode_insertSpace, METH_VARARGS, "SoMFNode_insertSpace(SoMFNode self, int start, int num)"},
	 { "SoMFNode___getitem__", _wrap_SoMFNode___getitem__, METH_VARARGS, "SoMFNode___getitem__(SoMFNode self, int i) -> SoNode"},
	 { "SoMFNode___setitem__", _wrap_SoMFNode___setitem__, METH_VARARGS, "SoMFNode___setitem__(SoMFNode self, int i, SoNode value)"},
	 { "SoMFNode_setValue", _wrap_SoMFNode_setValue, METH_VARARGS, "\n"
		"SoMFNode_setValue(SoMFNode self, SoNode value)\n"
		"SoMFNode_setValue(SoMFNode self, SoMFNode other)\n"
		""},
	 { "SoMFNode_getValues", _wrap_SoMFNode_getValues, METH_VARARGS, "SoMFNode_getValues(SoMFNode self, int i=0) -> SoNode"},
	 { "SoMFNode_swigregister", SoMFNode_swigregister, METH_O, NULL},
	 { "SoMFNode_swiginit", SoMFNode_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFPath", _wrap_new_SoMFPath, METH_NOARGS, "new_SoMFPath() -> SoMFPath"},
	 { "delete_SoMFPath", _wrap_delete_SoMFPath, METH_O, "delete_SoMFPath(SoMFPath self)"},
	 { "SoMFPath_createInstance", _wrap_SoMFPath_createInstance, METH_NOARGS, "SoMFPath_createInstance() -> void *"},
	 { "SoMFPath_getClassTypeId", _wrap_SoMFPath_getClassTypeId, METH_NOARGS, "SoMFPath_getClassTypeId() -> SoType"},
	 { "SoMFPath_getTypeId", _wrap_SoMFPath_getTypeId, METH_O, "SoMFPath_getTypeId(SoMFPath self) -> SoType"},
	 { "SoMFPath_copyFrom", _wrap_SoMFPath_copyFrom, METH_VARARGS, "SoMFPath_copyFrom(SoMFPath self, SoField field)"},
	 { "SoMFPath_isSame", _wrap_SoMFPath_isSame, METH_VARARGS, "SoMFPath_isSame(SoMFPath self, SoField field) -> SbBool"},
	 { "SoMFPath_find", _wrap_SoMFPath_find, METH_VARARGS, "SoMFPath_find(SoMFPath self, SoPath value, SbBool addifnotfound=0) -> int"},
	 { "SoMFPath_setValues", _wrap_SoMFPath_setValues, METH_VARARGS, "SoMFPath_setValues(SoMFPath self, int const start, int const num, SoPath const ** newvals)"},
	 { "SoMFPath_set1Value", _wrap_SoMFPath_set1Value, METH_VARARGS, "SoMFPath_set1Value(SoMFPath self, int const idx, SoPath value)"},
	 { "SoMFPath___eq__", _wrap_SoMFPath___eq__, METH_VARARGS, "SoMFPath___eq__(SoMFPath self, SoMFPath field) -> SbBool"},
	 { "SoMFPath___ne__", _wrap_SoMFPath___ne__, METH_VARARGS, "SoMFPath___ne__(SoMFPath self, SoMFPath field) -> SbBool"},
	 { "SoMFPath_startEditing", _wrap_SoMFPath_startEditing, METH_O, "SoMFPath_startEditing(SoMFPath self) -> SoPath **"},
	 { "SoMFPath_finishEditing", _wrap_SoMFPath_finishEditing, METH_O, "SoMFPath_finishEditing(SoMFPath self)"},
	 { "SoMFPath_initClass", _wrap_SoMFPath_initClass, METH_NOARGS, "SoMFPath_initClass()"},
	 { "SoMFPath_notify", _wrap_SoMFPath_notify, METH_VARARGS, "SoMFPath_notify(SoMFPath self, SoNotList l)"},
	 { "SoMFPath_fixCopy", _wrap_SoMFPath_fixCopy, METH_VARARGS, "SoMFPath_fixCopy(SoMFPath self, SbBool copyconnections)"},
	 { "SoMFPath_referencesCopy", _wrap_SoMFPath_referencesCopy, METH_O, "SoMFPath_referencesCopy(SoMFPath self) -> SbBool"},
	 { "SoMFPath_deleteValues", _wrap_SoMFPath_deleteValues, METH_VARARGS, "SoMFPath_deleteValues(SoMFPath self, int start, int num=-1)"},
	 { "SoMFPath_insertSpace", _wrap_SoMFPath_insertSpace, METH_VARARGS, "SoMFPath_insertSpace(SoMFPath self, int start, int num)"},
	 { "SoMFPath___getitem__", _wrap_SoMFPath___getitem__, METH_VARARGS, "SoMFPath___getitem__(SoMFPath self, int i) -> SoPath"},
	 { "SoMFPath___setitem__", _wrap_SoMFPath___setitem__, METH_VARARGS, "SoMFPath___setitem__(SoMFPath self, int i, SoPath value)"},
	 { "SoMFPath_setValue", _wrap_SoMFPath_setValue, METH_VARARGS, "\n"
		"SoMFPath_setValue(SoMFPath self, SoPath value)\n"
		"SoMFPath_setValue(SoMFPath self, SoMFPath other)\n"
		""},
	 { "SoMFPath_getValues", _wrap_SoMFPath_getValues, METH_VARARGS, "SoMFPath_getValues(SoMFPath self, int i=0) -> SoPath"},
	 { "SoMFPath_swigregister", SoMFPath_swigregister, METH_O, NULL},
	 { "SoMFPath_swiginit", SoMFPath_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFPlane", _wrap_new_SoMFPlane, METH_NOARGS, "new_SoMFPlane() -> SoMFPlane"},
	 { "delete_SoMFPlane", _wrap_delete_SoMFPlane, METH_O, "delete_SoMFPlane(SoMFPlane self)"},
	 { "SoMFPlane_createInstance", _wrap_SoMFPlane_createInstance, METH_NOARGS, "SoMFPlane_createInstance() -> void *"},
	 { "SoMFPlane_getClassTypeId", _wrap_SoMFPlane_getClassTypeId, METH_NOARGS, "SoMFPlane_getClassTypeId() -> SoType"},
	 { "SoMFPlane_getTypeId", _wrap_SoMFPlane_getTypeId, METH_O, "SoMFPlane_getTypeId(SoMFPlane self) -> SoType"},
	 { "SoMFPlane_copyFrom", _wrap_SoMFPlane_copyFrom, METH_VARARGS, "SoMFPlane_copyFrom(SoMFPlane self, SoField field)"},
	 { "SoMFPlane_isSame", _wrap_SoMFPlane_isSame, METH_VARARGS, "SoMFPlane_isSame(SoMFPlane self, SoField field) -> SbBool"},
	 { "SoMFPlane_find", _wrap_SoMFPlane_find, METH_VARARGS, "SoMFPlane_find(SoMFPlane self, SbPlane value, SbBool addifnotfound=0) -> int"},
	 { "SoMFPlane_setValues", _wrap_SoMFPlane_setValues, METH_VARARGS, "SoMFPlane_setValues(SoMFPlane self, int const start, int const num, SbPlane newvals)"},
	 { "SoMFPlane_set1Value", _wrap_SoMFPlane_set1Value, METH_VARARGS, "SoMFPlane_set1Value(SoMFPlane self, int const idx, SbPlane value)"},
	 { "SoMFPlane___eq__", _wrap_SoMFPlane___eq__, METH_VARARGS, "SoMFPlane___eq__(SoMFPlane self, SoMFPlane field) -> SbBool"},
	 { "SoMFPlane___ne__", _wrap_SoMFPlane___ne__, METH_VARARGS, "SoMFPlane___ne__(SoMFPlane self, SoMFPlane field) -> SbBool"},
	 { "SoMFPlane_startEditing", _wrap_SoMFPlane_startEditing, METH_O, "SoMFPlane_startEditing(SoMFPlane self) -> SbPlane"},
	 { "SoMFPlane_finishEditing", _wrap_SoMFPlane_finishEditing, METH_O, "SoMFPlane_finishEditing(SoMFPlane self)"},
	 { "SoMFPlane_initClass", _wrap_SoMFPlane_initClass, METH_NOARGS, "SoMFPlane_initClass()"},
	 { "SoMFPlane___getitem__", _wrap_SoMFPlane___getitem__, METH_VARARGS, "SoMFPlane___getitem__(SoMFPlane self, int i) -> SbPlane"},
	 { "SoMFPlane___setitem__", _wrap_SoMFPlane___setitem__, METH_VARARGS, "SoMFPlane___setitem__(SoMFPlane self, int i, SbPlane value)"},
	 { "SoMFPlane_getValues", _wrap_SoMFPlane_getValues, METH_VARARGS, "SoMFPlane_getValues(SoMFPlane self, int i=0) -> SbPlane"},
	 { "SoMFPlane_setValue", _wrap_SoMFPlane_setValue, METH_VARARGS, "\n"
		"SoMFPlane_setValue(SoMFPlane self, SbPlane value)\n"
		"SoMFPlane_setValue(SoMFPlane self, SoMFPlane other)\n"
		""},
	 { "SoMFPlane_swigregister", SoMFPlane_swigregister, METH_O, NULL},
	 { "SoMFPlane_swiginit", SoMFPlane_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFShort", _wrap_new_SoMFShort, METH_NOARGS, "new_SoMFShort() -> SoMFShort"},
	 { "delete_SoMFShort", _wrap_delete_SoMFShort, METH_O, "delete_SoMFShort(SoMFShort self)"},
	 { "SoMFShort_createInstance", _wrap_SoMFShort_createInstance, METH_NOARGS, "SoMFShort_createInstance() -> void *"},
	 { "SoMFShort_getClassTypeId", _wrap_SoMFShort_getClassTypeId, METH_NOARGS, "SoMFShort_getClassTypeId() -> SoType"},
	 { "SoMFShort_getTypeId", _wrap_SoMFShort_getTypeId, METH_O, "SoMFShort_getTypeId(SoMFShort self) -> SoType"},
	 { "SoMFShort_copyFrom", _wrap_SoMFShort_copyFrom, METH_VARARGS, "SoMFShort_copyFrom(SoMFShort self, SoField field)"},
	 { "SoMFShort_isSame", _wrap_SoMFShort_isSame, METH_VARARGS, "SoMFShort_isSame(SoMFShort self, SoField field) -> SbBool"},
	 { "SoMFShort_find", _wrap_SoMFShort_find, METH_VARARGS, "SoMFShort_find(SoMFShort self, short value, SbBool addifnotfound=0) -> int"},
	 { "SoMFShort_setValues", _wrap_SoMFShort_setValues, METH_VARARGS, "SoMFShort_setValues(SoMFShort self, int const start, int const num, short const * newvals)"},
	 { "SoMFShort_set1Value", _wrap_SoMFShort_set1Value, METH_VARARGS, "SoMFShort_set1Value(SoMFShort self, int const idx, short value)"},
	 { "SoMFShort___eq__", _wrap_SoMFShort___eq__, METH_VARARGS, "SoMFShort___eq__(SoMFShort self, SoMFShort field) -> SbBool"},
	 { "SoMFShort___ne__", _wrap_SoMFShort___ne__, METH_VARARGS, "SoMFShort___ne__(SoMFShort self, SoMFShort field) -> SbBool"},
	 { "SoMFShort_startEditing", _wrap_SoMFShort_startEditing, METH_O, "SoMFShort_startEditing(SoMFShort self) -> short *"},
	 { "SoMFShort_finishEditing", _wrap_SoMFShort_finishEditing, METH_O, "SoMFShort_finishEditing(SoMFShort self)"},
	 { "SoMFShort_setValuesPointer", _wrap_SoMFShort_setValuesPointer, METH_VARARGS, "\n"
		"SoMFShort_setValuesPointer(SoMFShort self, int const num, short const * userdata)\n"
		"SoMFShort_setValuesPointer(SoMFShort self, int const num, short * userdata)\n"
		""},
	 { "SoMFShort_initClass", _wrap_SoMFShort_initClass, METH_NOARGS, "SoMFShort_initClass()"},
	 { "SoMFShort___getitem__", _wrap_SoMFShort___getitem__, METH_VARARGS, "SoMFShort___getitem__(SoMFShort self, int i) -> short const"},
	 { "SoMFShort___setitem__", _wrap_SoMFShort___setitem__, METH_VARARGS, "SoMFShort___setitem__(SoMFShort self, int i, short value)"},
	 { "SoMFShort_setValue", _wrap_SoMFShort_setValue, METH_VARARGS, "\n"
		"SoMFShort_setValue(SoMFShort self, short value)\n"
		"SoMFShort_setValue(SoMFShort self, SoMFShort other)\n"
		""},
	 { "SoMFShort_getValues", _wrap_SoMFShort_getValues, METH_VARARGS, "SoMFShort_getValues(SoMFShort self, int i=0) -> short const"},
	 { "SoMFShort_swigregister", SoMFShort_swigregister, METH_O, NULL},
	 { "SoMFShort_swiginit", SoMFShort_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFTime", _wrap_new_SoMFTime, METH_NOARGS, "new_SoMFTime() -> SoMFTime"},
	 { "delete_SoMFTime", _wrap_delete_SoMFTime, METH_O, "delete_SoMFTime(SoMFTime self)"},
	 { "SoMFTime_createInstance", _wrap_SoMFTime_createInstance, METH_NOARGS, "SoMFTime_createInstance() -> void *"},
	 { "SoMFTime_getClassTypeId", _wrap_SoMFTime_getClassTypeId, METH_NOARGS, "SoMFTime_getClassTypeId() -> SoType"},
	 { "SoMFTime_getTypeId", _wrap_SoMFTime_getTypeId, METH_O, "SoMFTime_getTypeId(SoMFTime self) -> SoType"},
	 { "SoMFTime_copyFrom", _wrap_SoMFTime_copyFrom, METH_VARARGS, "SoMFTime_copyFrom(SoMFTime self, SoField field)"},
	 { "SoMFTime_isSame", _wrap_SoMFTime_isSame, METH_VARARGS, "SoMFTime_isSame(SoMFTime self, SoField field) -> SbBool"},
	 { "SoMFTime_find", _wrap_SoMFTime_find, METH_VARARGS, "SoMFTime_find(SoMFTime self, SbTime value, SbBool addifnotfound=0) -> int"},
	 { "SoMFTime_setValues", _wrap_SoMFTime_setValues, METH_VARARGS, "SoMFTime_setValues(SoMFTime self, int const start, int const num, SbTime newvals)"},
	 { "SoMFTime_set1Value", _wrap_SoMFTime_set1Value, METH_VARARGS, "SoMFTime_set1Value(SoMFTime self, int const idx, SbTime value)"},
	 { "SoMFTime___eq__", _wrap_SoMFTime___eq__, METH_VARARGS, "SoMFTime___eq__(SoMFTime self, SoMFTime field) -> SbBool"},
	 { "SoMFTime___ne__", _wrap_SoMFTime___ne__, METH_VARARGS, "SoMFTime___ne__(SoMFTime self, SoMFTime field) -> SbBool"},
	 { "SoMFTime_startEditing", _wrap_SoMFTime_startEditing, METH_O, "SoMFTime_startEditing(SoMFTime self) -> SbTime"},
	 { "SoMFTime_finishEditing", _wrap_SoMFTime_finishEditing, METH_O, "SoMFTime_finishEditing(SoMFTime self)"},
	 { "SoMFTime_initClass", _wrap_SoMFTime_initClass, METH_NOARGS, "SoMFTime_initClass()"},
	 { "SoMFTime___getitem__", _wrap_SoMFTime___getitem__, METH_VARARGS, "SoMFTime___getitem__(SoMFTime self, int i) -> SbTime"},
	 { "SoMFTime___setitem__", _wrap_SoMFTime___setitem__, METH_VARARGS, "SoMFTime___setitem__(SoMFTime self, int i, SbTime value)"},
	 { "SoMFTime_getValues", _wrap_SoMFTime_getValues, METH_VARARGS, "SoMFTime_getValues(SoMFTime self, int i=0) -> SbTime"},
	 { "SoMFTime_setValue", _wrap_SoMFTime_setValue, METH_VARARGS, "\n"
		"SoMFTime_setValue(SoMFTime self, SbTime value)\n"
		"SoMFTime_setValue(SoMFTime self, SoMFTime other)\n"
		""},
	 { "SoMFTime_swigregister", SoMFTime_swigregister, METH_O, NULL},
	 { "SoMFTime_swiginit", SoMFTime_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFUInt32", _wrap_new_SoMFUInt32, METH_NOARGS, "new_SoMFUInt32() -> SoMFUInt32"},
	 { "delete_SoMFUInt32", _wrap_delete_SoMFUInt32, METH_O, "delete_SoMFUInt32(SoMFUInt32 self)"},
	 { "SoMFUInt32_createInstance", _wrap_SoMFUInt32_createInstance, METH_NOARGS, "SoMFUInt32_createInstance() -> void *"},
	 { "SoMFUInt32_getClassTypeId", _wrap_SoMFUInt32_getClassTypeId, METH_NOARGS, "SoMFUInt32_getClassTypeId() -> SoType"},
	 { "SoMFUInt32_getTypeId", _wrap_SoMFUInt32_getTypeId, METH_O, "SoMFUInt32_getTypeId(SoMFUInt32 self) -> SoType"},
	 { "SoMFUInt32_copyFrom", _wrap_SoMFUInt32_copyFrom, METH_VARARGS, "SoMFUInt32_copyFrom(SoMFUInt32 self, SoField field)"},
	 { "SoMFUInt32_isSame", _wrap_SoMFUInt32_isSame, METH_VARARGS, "SoMFUInt32_isSame(SoMFUInt32 self, SoField field) -> SbBool"},
	 { "SoMFUInt32_find", _wrap_SoMFUInt32_find, METH_VARARGS, "SoMFUInt32_find(SoMFUInt32 self, uint32_t value, SbBool addifnotfound=0) -> int"},
	 { "SoMFUInt32_setValues", _wrap_SoMFUInt32_setValues, METH_VARARGS, "SoMFUInt32_setValues(SoMFUInt32 self, int const start, int const num, uint32_t const * newvals)"},
	 { "SoMFUInt32_set1Value", _wrap_SoMFUInt32_set1Value, METH_VARARGS, "SoMFUInt32_set1Value(SoMFUInt32 self, int const idx, uint32_t value)"},
	 { "SoMFUInt32___eq__", _wrap_SoMFUInt32___eq__, METH_VARARGS, "SoMFUInt32___eq__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"},
	 { "SoMFUInt32___ne__", _wrap_SoMFUInt32___ne__, METH_VARARGS, "SoMFUInt32___ne__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"},
	 { "SoMFUInt32_startEditing", _wrap_SoMFUInt32_startEditing, METH_O, "SoMFUInt32_startEditing(SoMFUInt32 self) -> uint32_t *"},
	 { "SoMFUInt32_finishEditing", _wrap_SoMFUInt32_finishEditing, METH_O, "SoMFUInt32_finishEditing(SoMFUInt32 self)"},
	 { "SoMFUInt32_setValuesPointer", _wrap_SoMFUInt32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFUInt32_setValuesPointer(SoMFUInt32 self, int const num, uint32_t const * userdata)\n"
		"SoMFUInt32_setValuesPointer(SoMFUInt32 self, int const num, uint32_t * userdata)\n"
		""},
	 { "SoMFUInt32_initClass", _wrap_SoMFUInt32_initClass, METH_NOARGS, "SoMFUInt32_initClass()"},
	 { "SoMFUInt32___getitem__", _wrap_SoMFUInt32___getitem__, METH_VARARGS, "SoMFUInt32___getitem__(SoMFUInt32 self, int i) -> uint32_t const"},
	 { "SoMFUInt32___setitem__", _wrap_SoMFUInt32___setitem__, METH_VARARGS, "SoMFUInt32___setitem__(SoMFUInt32 self, int i, uint32_t value)"},
	 { "SoMFUInt32_setValue", _wrap_SoMFUInt32_setValue, METH_VARARGS, "\n"
		"SoMFUInt32_setValue(SoMFUInt32 self, uint32_t value)\n"
		"SoMFUInt32_setValue(SoMFUInt32 self, SoMFUInt32 other)\n"
		""},
	 { "SoMFUInt32_getValues", _wrap_SoMFUInt32_getValues, METH_VARARGS, "SoMFUInt32_getValues(SoMFUInt32 self, int i=0) -> uint32_t const"},
	 { "SoMFUInt32_swigregister", SoMFUInt32_swigregister, METH_O, NULL},
	 { "SoMFUInt32_swiginit", SoMFUInt32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFUShort", _wrap_new_SoMFUShort, METH_NOARGS, "new_SoMFUShort() -> SoMFUShort"},
	 { "delete_SoMFUShort", _wrap_delete_SoMFUShort, METH_O, "delete_SoMFUShort(SoMFUShort self)"},
	 { "SoMFUShort_createInstance", _wrap_SoMFUShort_createInstance, METH_NOARGS, "SoMFUShort_createInstance() -> void *"},
	 { "SoMFUShort_getClassTypeId", _wrap_SoMFUShort_getClassTypeId, METH_NOARGS, "SoMFUShort_getClassTypeId() -> SoType"},
	 { "SoMFUShort_getTypeId", _wrap_SoMFUShort_getTypeId, METH_O, "SoMFUShort_getTypeId(SoMFUShort self) -> SoType"},
	 { "SoMFUShort_copyFrom", _wrap_SoMFUShort_copyFrom, METH_VARARGS, "SoMFUShort_copyFrom(SoMFUShort self, SoField field)"},
	 { "SoMFUShort_isSame", _wrap_SoMFUShort_isSame, METH_VARARGS, "SoMFUShort_isSame(SoMFUShort self, SoField field) -> SbBool"},
	 { "SoMFUShort_find", _wrap_SoMFUShort_find, METH_VARARGS, "SoMFUShort_find(SoMFUShort self, unsigned short value, SbBool addifnotfound=0) -> int"},
	 { "SoMFUShort_setValues", _wrap_SoMFUShort_setValues, METH_VARARGS, "SoMFUShort_setValues(SoMFUShort self, int const start, int const num, unsigned short const * newvals)"},
	 { "SoMFUShort_set1Value", _wrap_SoMFUShort_set1Value, METH_VARARGS, "SoMFUShort_set1Value(SoMFUShort self, int const idx, unsigned short value)"},
	 { "SoMFUShort___eq__", _wrap_SoMFUShort___eq__, METH_VARARGS, "SoMFUShort___eq__(SoMFUShort self, SoMFUShort field) -> SbBool"},
	 { "SoMFUShort___ne__", _wrap_SoMFUShort___ne__, METH_VARARGS, "SoMFUShort___ne__(SoMFUShort self, SoMFUShort field) -> SbBool"},
	 { "SoMFUShort_startEditing", _wrap_SoMFUShort_startEditing, METH_O, "SoMFUShort_startEditing(SoMFUShort self) -> unsigned short *"},
	 { "SoMFUShort_finishEditing", _wrap_SoMFUShort_finishEditing, METH_O, "SoMFUShort_finishEditing(SoMFUShort self)"},
	 { "SoMFUShort_setValuesPointer", _wrap_SoMFUShort_setValuesPointer, METH_VARARGS, "\n"
		"SoMFUShort_setValuesPointer(SoMFUShort self, int const num, unsigned short const * userdata)\n"
		"SoMFUShort_setValuesPointer(SoMFUShort self, int const num, unsigned short * userdata)\n"
		""},
	 { "SoMFUShort_initClass", _wrap_SoMFUShort_initClass, METH_NOARGS, "SoMFUShort_initClass()"},
	 { "SoMFUShort___getitem__", _wrap_SoMFUShort___getitem__, METH_VARARGS, "SoMFUShort___getitem__(SoMFUShort self, int i) -> short const"},
	 { "SoMFUShort___setitem__", _wrap_SoMFUShort___setitem__, METH_VARARGS, "SoMFUShort___setitem__(SoMFUShort self, int i, short value)"},
	 { "SoMFUShort_setValue", _wrap_SoMFUShort_setValue, METH_VARARGS, "\n"
		"SoMFUShort_setValue(SoMFUShort self, unsigned short value)\n"
		"SoMFUShort_setValue(SoMFUShort self, SoMFUShort other)\n"
		""},
	 { "SoMFUShort_getValues", _wrap_SoMFUShort_getValues, METH_VARARGS, "SoMFUShort_getValues(SoMFUShort self, int i=0) -> unsigned short const"},
	 { "SoMFUShort_swigregister", SoMFUShort_swigregister, METH_O, NULL},
	 { "SoMFUShort_swiginit", SoMFUShort_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec2b", _wrap_new_SoMFVec2b, METH_NOARGS, "new_SoMFVec2b() -> SoMFVec2b"},
	 { "delete_SoMFVec2b", _wrap_delete_SoMFVec2b, METH_O, "delete_SoMFVec2b(SoMFVec2b self)"},
	 { "SoMFVec2b_createInstance", _wrap_SoMFVec2b_createInstance, METH_NOARGS, "SoMFVec2b_createInstance() -> void *"},
	 { "SoMFVec2b_getClassTypeId", _wrap_SoMFVec2b_getClassTypeId, METH_NOARGS, "SoMFVec2b_getClassTypeId() -> SoType"},
	 { "SoMFVec2b_getTypeId", _wrap_SoMFVec2b_getTypeId, METH_O, "SoMFVec2b_getTypeId(SoMFVec2b self) -> SoType"},
	 { "SoMFVec2b_copyFrom", _wrap_SoMFVec2b_copyFrom, METH_VARARGS, "SoMFVec2b_copyFrom(SoMFVec2b self, SoField field)"},
	 { "SoMFVec2b_isSame", _wrap_SoMFVec2b_isSame, METH_VARARGS, "SoMFVec2b_isSame(SoMFVec2b self, SoField field) -> SbBool"},
	 { "SoMFVec2b_getValues", _wrap_SoMFVec2b_getValues, METH_VARARGS, "SoMFVec2b_getValues(SoMFVec2b self, int const start) -> SbVec2b"},
	 { "SoMFVec2b_find", _wrap_SoMFVec2b_find, METH_VARARGS, "SoMFVec2b_find(SoMFVec2b self, SbVec2b value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec2b___eq__", _wrap_SoMFVec2b___eq__, METH_VARARGS, "SoMFVec2b___eq__(SoMFVec2b self, SoMFVec2b field) -> SbBool"},
	 { "SoMFVec2b___ne__", _wrap_SoMFVec2b___ne__, METH_VARARGS, "SoMFVec2b___ne__(SoMFVec2b self, SoMFVec2b field) -> SbBool"},
	 { "SoMFVec2b_startEditing", _wrap_SoMFVec2b_startEditing, METH_O, "SoMFVec2b_startEditing(SoMFVec2b self) -> SbVec2b"},
	 { "SoMFVec2b_finishEditing", _wrap_SoMFVec2b_finishEditing, METH_O, "SoMFVec2b_finishEditing(SoMFVec2b self)"},
	 { "SoMFVec2b_setValuesPointer", _wrap_SoMFVec2b_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec2b_setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)\n"
		"SoMFVec2b_setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)\n"
		"SoMFVec2b_setValuesPointer(SoMFVec2b self, int const num, int8_t const * userdata)\n"
		"SoMFVec2b_setValuesPointer(SoMFVec2b self, int const num, int8_t * userdata)\n"
		""},
	 { "SoMFVec2b_initClass", _wrap_SoMFVec2b_initClass, METH_NOARGS, "SoMFVec2b_initClass()"},
	 { "SoMFVec2b_setValues", _wrap_SoMFVec2b_setValues, METH_VARARGS, "\n"
		"SoMFVec2b_setValues(SoMFVec2b self, int const start, int const num, SbVec2b newvals)\n"
		"SoMFVec2b_setValues(SoMFVec2b self, int start, int num, int8_t const [][2] xy)\n"
		""},
	 { "SoMFVec2b_set1Value", _wrap_SoMFVec2b_set1Value, METH_VARARGS, "\n"
		"SoMFVec2b_set1Value(SoMFVec2b self, int const idx, SbVec2b value)\n"
		"SoMFVec2b_set1Value(SoMFVec2b self, int idx, int8_t x, int8_t y)\n"
		"SoMFVec2b_set1Value(SoMFVec2b self, int idx, int8_t const [2] xy)\n"
		""},
	 { "SoMFVec2b_setValue", _wrap_SoMFVec2b_setValue, METH_VARARGS, "\n"
		"SoMFVec2b_setValue(SoMFVec2b self, SbVec2b value)\n"
		"SoMFVec2b_setValue(SoMFVec2b self, int8_t x, int8_t y)\n"
		"SoMFVec2b_setValue(SoMFVec2b self, int8_t const [2] xy)\n"
		""},
	 { "SoMFVec2b_swigregister", SoMFVec2b_swigregister, METH_O, NULL},
	 { "SoMFVec2b_swiginit", SoMFVec2b_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec2s", _wrap_new_SoMFVec2s, METH_NOARGS, "new_SoMFVec2s() -> SoMFVec2s"},
	 { "delete_SoMFVec2s", _wrap_delete_SoMFVec2s, METH_O, "delete_SoMFVec2s(SoMFVec2s self)"},
	 { "SoMFVec2s_createInstance", _wrap_SoMFVec2s_createInstance, METH_NOARGS, "SoMFVec2s_createInstance() -> void *"},
	 { "SoMFVec2s_getClassTypeId", _wrap_SoMFVec2s_getClassTypeId, METH_NOARGS, "SoMFVec2s_getClassTypeId() -> SoType"},
	 { "SoMFVec2s_getTypeId", _wrap_SoMFVec2s_getTypeId, METH_O, "SoMFVec2s_getTypeId(SoMFVec2s self) -> SoType"},
	 { "SoMFVec2s_copyFrom", _wrap_SoMFVec2s_copyFrom, METH_VARARGS, "SoMFVec2s_copyFrom(SoMFVec2s self, SoField field)"},
	 { "SoMFVec2s_isSame", _wrap_SoMFVec2s_isSame, METH_VARARGS, "SoMFVec2s_isSame(SoMFVec2s self, SoField field) -> SbBool"},
	 { "SoMFVec2s_getValues", _wrap_SoMFVec2s_getValues, METH_VARARGS, "SoMFVec2s_getValues(SoMFVec2s self, int const start) -> SbVec2s"},
	 { "SoMFVec2s_find", _wrap_SoMFVec2s_find, METH_VARARGS, "SoMFVec2s_find(SoMFVec2s self, SbVec2s value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec2s___eq__", _wrap_SoMFVec2s___eq__, METH_VARARGS, "SoMFVec2s___eq__(SoMFVec2s self, SoMFVec2s field) -> SbBool"},
	 { "SoMFVec2s___ne__", _wrap_SoMFVec2s___ne__, METH_VARARGS, "SoMFVec2s___ne__(SoMFVec2s self, SoMFVec2s field) -> SbBool"},
	 { "SoMFVec2s_startEditing", _wrap_SoMFVec2s_startEditing, METH_O, "SoMFVec2s_startEditing(SoMFVec2s self) -> SbVec2s"},
	 { "SoMFVec2s_finishEditing", _wrap_SoMFVec2s_finishEditing, METH_O, "SoMFVec2s_finishEditing(SoMFVec2s self)"},
	 { "SoMFVec2s_setValuesPointer", _wrap_SoMFVec2s_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec2s_setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)\n"
		"SoMFVec2s_setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)\n"
		"SoMFVec2s_setValuesPointer(SoMFVec2s self, int const num, short const * userdata)\n"
		"SoMFVec2s_setValuesPointer(SoMFVec2s self, int const num, short * userdata)\n"
		""},
	 { "SoMFVec2s_initClass", _wrap_SoMFVec2s_initClass, METH_NOARGS, "SoMFVec2s_initClass()"},
	 { "SoMFVec2s_setValues", _wrap_SoMFVec2s_setValues, METH_VARARGS, "\n"
		"SoMFVec2s_setValues(SoMFVec2s self, int const start, int const num, SbVec2s newvals)\n"
		"SoMFVec2s_setValues(SoMFVec2s self, int start, int num, short const [][2] xy)\n"
		""},
	 { "SoMFVec2s_set1Value", _wrap_SoMFVec2s_set1Value, METH_VARARGS, "\n"
		"SoMFVec2s_set1Value(SoMFVec2s self, int const idx, SbVec2s value)\n"
		"SoMFVec2s_set1Value(SoMFVec2s self, int idx, short x, short y)\n"
		"SoMFVec2s_set1Value(SoMFVec2s self, int idx, short const [2] xy)\n"
		""},
	 { "SoMFVec2s_setValue", _wrap_SoMFVec2s_setValue, METH_VARARGS, "\n"
		"SoMFVec2s_setValue(SoMFVec2s self, SbVec2s value)\n"
		"SoMFVec2s_setValue(SoMFVec2s self, short x, short y)\n"
		"SoMFVec2s_setValue(SoMFVec2s self, short const [2] xy)\n"
		""},
	 { "SoMFVec2s_swigregister", SoMFVec2s_swigregister, METH_O, NULL},
	 { "SoMFVec2s_swiginit", SoMFVec2s_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec2i32", _wrap_new_SoMFVec2i32, METH_NOARGS, "new_SoMFVec2i32() -> SoMFVec2i32"},
	 { "delete_SoMFVec2i32", _wrap_delete_SoMFVec2i32, METH_O, "delete_SoMFVec2i32(SoMFVec2i32 self)"},
	 { "SoMFVec2i32_createInstance", _wrap_SoMFVec2i32_createInstance, METH_NOARGS, "SoMFVec2i32_createInstance() -> void *"},
	 { "SoMFVec2i32_getClassTypeId", _wrap_SoMFVec2i32_getClassTypeId, METH_NOARGS, "SoMFVec2i32_getClassTypeId() -> SoType"},
	 { "SoMFVec2i32_getTypeId", _wrap_SoMFVec2i32_getTypeId, METH_O, "SoMFVec2i32_getTypeId(SoMFVec2i32 self) -> SoType"},
	 { "SoMFVec2i32_copyFrom", _wrap_SoMFVec2i32_copyFrom, METH_VARARGS, "SoMFVec2i32_copyFrom(SoMFVec2i32 self, SoField field)"},
	 { "SoMFVec2i32_isSame", _wrap_SoMFVec2i32_isSame, METH_VARARGS, "SoMFVec2i32_isSame(SoMFVec2i32 self, SoField field) -> SbBool"},
	 { "SoMFVec2i32_getValues", _wrap_SoMFVec2i32_getValues, METH_VARARGS, "SoMFVec2i32_getValues(SoMFVec2i32 self, int const start) -> SbVec2i32"},
	 { "SoMFVec2i32_find", _wrap_SoMFVec2i32_find, METH_VARARGS, "SoMFVec2i32_find(SoMFVec2i32 self, SbVec2i32 value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec2i32___eq__", _wrap_SoMFVec2i32___eq__, METH_VARARGS, "SoMFVec2i32___eq__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"},
	 { "SoMFVec2i32___ne__", _wrap_SoMFVec2i32___ne__, METH_VARARGS, "SoMFVec2i32___ne__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"},
	 { "SoMFVec2i32_startEditing", _wrap_SoMFVec2i32_startEditing, METH_O, "SoMFVec2i32_startEditing(SoMFVec2i32 self) -> SbVec2i32"},
	 { "SoMFVec2i32_finishEditing", _wrap_SoMFVec2i32_finishEditing, METH_O, "SoMFVec2i32_finishEditing(SoMFVec2i32 self)"},
	 { "SoMFVec2i32_setValuesPointer", _wrap_SoMFVec2i32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec2i32_setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)\n"
		"SoMFVec2i32_setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)\n"
		"SoMFVec2i32_setValuesPointer(SoMFVec2i32 self, int const num, int32_t const * userdata)\n"
		"SoMFVec2i32_setValuesPointer(SoMFVec2i32 self, int const num, int32_t * userdata)\n"
		""},
	 { "SoMFVec2i32_initClass", _wrap_SoMFVec2i32_initClass, METH_NOARGS, "SoMFVec2i32_initClass()"},
	 { "SoMFVec2i32_setValues", _wrap_SoMFVec2i32_setValues, METH_VARARGS, "\n"
		"SoMFVec2i32_setValues(SoMFVec2i32 self, int const start, int const num, SbVec2i32 newvals)\n"
		"SoMFVec2i32_setValues(SoMFVec2i32 self, int start, int num, int32_t const [][2] xy)\n"
		""},
	 { "SoMFVec2i32_set1Value", _wrap_SoMFVec2i32_set1Value, METH_VARARGS, "\n"
		"SoMFVec2i32_set1Value(SoMFVec2i32 self, int const idx, SbVec2i32 value)\n"
		"SoMFVec2i32_set1Value(SoMFVec2i32 self, int idx, int32_t x, int32_t y)\n"
		"SoMFVec2i32_set1Value(SoMFVec2i32 self, int idx, int32_t const [2] xy)\n"
		""},
	 { "SoMFVec2i32_setValue", _wrap_SoMFVec2i32_setValue, METH_VARARGS, "\n"
		"SoMFVec2i32_setValue(SoMFVec2i32 self, SbVec2i32 value)\n"
		"SoMFVec2i32_setValue(SoMFVec2i32 self, int32_t x, int32_t y)\n"
		"SoMFVec2i32_setValue(SoMFVec2i32 self, int32_t const [2] xy)\n"
		""},
	 { "SoMFVec2i32_swigregister", SoMFVec2i32_swigregister, METH_O, NULL},
	 { "SoMFVec2i32_swiginit", SoMFVec2i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec2d", _wrap_new_SoMFVec2d, METH_NOARGS, "new_SoMFVec2d() -> SoMFVec2d"},
	 { "delete_SoMFVec2d", _wrap_delete_SoMFVec2d, METH_O, "delete_SoMFVec2d(SoMFVec2d self)"},
	 { "SoMFVec2d_createInstance", _wrap_SoMFVec2d_createInstance, METH_NOARGS, "SoMFVec2d_createInstance() -> void *"},
	 { "SoMFVec2d_getClassTypeId", _wrap_SoMFVec2d_getClassTypeId, METH_NOARGS, "SoMFVec2d_getClassTypeId() -> SoType"},
	 { "SoMFVec2d_getTypeId", _wrap_SoMFVec2d_getTypeId, METH_O, "SoMFVec2d_getTypeId(SoMFVec2d self) -> SoType"},
	 { "SoMFVec2d_copyFrom", _wrap_SoMFVec2d_copyFrom, METH_VARARGS, "SoMFVec2d_copyFrom(SoMFVec2d self, SoField field)"},
	 { "SoMFVec2d_isSame", _wrap_SoMFVec2d_isSame, METH_VARARGS, "SoMFVec2d_isSame(SoMFVec2d self, SoField field) -> SbBool"},
	 { "SoMFVec2d_getValues", _wrap_SoMFVec2d_getValues, METH_VARARGS, "SoMFVec2d_getValues(SoMFVec2d self, int const start) -> SbVec2d"},
	 { "SoMFVec2d_find", _wrap_SoMFVec2d_find, METH_VARARGS, "SoMFVec2d_find(SoMFVec2d self, SbVec2d value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec2d___eq__", _wrap_SoMFVec2d___eq__, METH_VARARGS, "SoMFVec2d___eq__(SoMFVec2d self, SoMFVec2d field) -> SbBool"},
	 { "SoMFVec2d___ne__", _wrap_SoMFVec2d___ne__, METH_VARARGS, "SoMFVec2d___ne__(SoMFVec2d self, SoMFVec2d field) -> SbBool"},
	 { "SoMFVec2d_startEditing", _wrap_SoMFVec2d_startEditing, METH_O, "SoMFVec2d_startEditing(SoMFVec2d self) -> SbVec2d"},
	 { "SoMFVec2d_finishEditing", _wrap_SoMFVec2d_finishEditing, METH_O, "SoMFVec2d_finishEditing(SoMFVec2d self)"},
	 { "SoMFVec2d_setValuesPointer", _wrap_SoMFVec2d_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec2d_setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)\n"
		"SoMFVec2d_setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)\n"
		"SoMFVec2d_setValuesPointer(SoMFVec2d self, int const num, double const * userdata)\n"
		"SoMFVec2d_setValuesPointer(SoMFVec2d self, int const num, double * userdata)\n"
		""},
	 { "SoMFVec2d_initClass", _wrap_SoMFVec2d_initClass, METH_NOARGS, "SoMFVec2d_initClass()"},
	 { "SoMFVec2d_setValues", _wrap_SoMFVec2d_setValues, METH_VARARGS, "\n"
		"SoMFVec2d_setValues(SoMFVec2d self, int const start, int const num, SbVec2d newvals)\n"
		"SoMFVec2d_setValues(SoMFVec2d self, int start, int num, double const [][2] xy)\n"
		""},
	 { "SoMFVec2d_set1Value", _wrap_SoMFVec2d_set1Value, METH_VARARGS, "\n"
		"SoMFVec2d_set1Value(SoMFVec2d self, int const idx, SbVec2d value)\n"
		"SoMFVec2d_set1Value(SoMFVec2d self, int idx, double x, double y)\n"
		"SoMFVec2d_set1Value(SoMFVec2d self, int idx, double const [2] xy)\n"
		""},
	 { "SoMFVec2d_setValue", _wrap_SoMFVec2d_setValue, METH_VARARGS, "\n"
		"SoMFVec2d_setValue(SoMFVec2d self, SbVec2d value)\n"
		"SoMFVec2d_setValue(SoMFVec2d self, double x, double y)\n"
		"SoMFVec2d_setValue(SoMFVec2d self, double const [2] xy)\n"
		""},
	 { "SoMFVec2d_swigregister", SoMFVec2d_swigregister, METH_O, NULL},
	 { "SoMFVec2d_swiginit", SoMFVec2d_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec3b", _wrap_new_SoMFVec3b, METH_NOARGS, "new_SoMFVec3b() -> SoMFVec3b"},
	 { "delete_SoMFVec3b", _wrap_delete_SoMFVec3b, METH_O, "delete_SoMFVec3b(SoMFVec3b self)"},
	 { "SoMFVec3b_createInstance", _wrap_SoMFVec3b_createInstance, METH_NOARGS, "SoMFVec3b_createInstance() -> void *"},
	 { "SoMFVec3b_getClassTypeId", _wrap_SoMFVec3b_getClassTypeId, METH_NOARGS, "SoMFVec3b_getClassTypeId() -> SoType"},
	 { "SoMFVec3b_getTypeId", _wrap_SoMFVec3b_getTypeId, METH_O, "SoMFVec3b_getTypeId(SoMFVec3b self) -> SoType"},
	 { "SoMFVec3b_copyFrom", _wrap_SoMFVec3b_copyFrom, METH_VARARGS, "SoMFVec3b_copyFrom(SoMFVec3b self, SoField field)"},
	 { "SoMFVec3b_isSame", _wrap_SoMFVec3b_isSame, METH_VARARGS, "SoMFVec3b_isSame(SoMFVec3b self, SoField field) -> SbBool"},
	 { "SoMFVec3b_getValues", _wrap_SoMFVec3b_getValues, METH_VARARGS, "SoMFVec3b_getValues(SoMFVec3b self, int const start) -> SbVec3b"},
	 { "SoMFVec3b_find", _wrap_SoMFVec3b_find, METH_VARARGS, "SoMFVec3b_find(SoMFVec3b self, SbVec3b value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec3b___eq__", _wrap_SoMFVec3b___eq__, METH_VARARGS, "SoMFVec3b___eq__(SoMFVec3b self, SoMFVec3b field) -> SbBool"},
	 { "SoMFVec3b___ne__", _wrap_SoMFVec3b___ne__, METH_VARARGS, "SoMFVec3b___ne__(SoMFVec3b self, SoMFVec3b field) -> SbBool"},
	 { "SoMFVec3b_startEditing", _wrap_SoMFVec3b_startEditing, METH_O, "SoMFVec3b_startEditing(SoMFVec3b self) -> SbVec3b"},
	 { "SoMFVec3b_finishEditing", _wrap_SoMFVec3b_finishEditing, METH_O, "SoMFVec3b_finishEditing(SoMFVec3b self)"},
	 { "SoMFVec3b_setValuesPointer", _wrap_SoMFVec3b_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec3b_setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)\n"
		"SoMFVec3b_setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)\n"
		"SoMFVec3b_setValuesPointer(SoMFVec3b self, int const num, int8_t const * userdata)\n"
		"SoMFVec3b_setValuesPointer(SoMFVec3b self, int const num, int8_t * userdata)\n"
		""},
	 { "SoMFVec3b_initClass", _wrap_SoMFVec3b_initClass, METH_NOARGS, "SoMFVec3b_initClass()"},
	 { "SoMFVec3b_setValues", _wrap_SoMFVec3b_setValues, METH_VARARGS, "\n"
		"SoMFVec3b_setValues(SoMFVec3b self, int const start, int const num, SbVec3b newvals)\n"
		"SoMFVec3b_setValues(SoMFVec3b self, int start, int num, int8_t const [][3] xyz)\n"
		""},
	 { "SoMFVec3b_set1Value", _wrap_SoMFVec3b_set1Value, METH_VARARGS, "\n"
		"SoMFVec3b_set1Value(SoMFVec3b self, int const idx, SbVec3b value)\n"
		"SoMFVec3b_set1Value(SoMFVec3b self, int idx, int8_t x, int8_t y, int8_t z)\n"
		"SoMFVec3b_set1Value(SoMFVec3b self, int idx, int8_t const [3] xyz)\n"
		""},
	 { "SoMFVec3b_setValue", _wrap_SoMFVec3b_setValue, METH_VARARGS, "\n"
		"SoMFVec3b_setValue(SoMFVec3b self, SbVec3b value)\n"
		"SoMFVec3b_setValue(SoMFVec3b self, int8_t x, int8_t y, int8_t z)\n"
		"SoMFVec3b_setValue(SoMFVec3b self, int8_t const [3] xyz)\n"
		""},
	 { "SoMFVec3b_swigregister", SoMFVec3b_swigregister, METH_O, NULL},
	 { "SoMFVec3b_swiginit", SoMFVec3b_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec3s", _wrap_new_SoMFVec3s, METH_NOARGS, "new_SoMFVec3s() -> SoMFVec3s"},
	 { "delete_SoMFVec3s", _wrap_delete_SoMFVec3s, METH_O, "delete_SoMFVec3s(SoMFVec3s self)"},
	 { "SoMFVec3s_createInstance", _wrap_SoMFVec3s_createInstance, METH_NOARGS, "SoMFVec3s_createInstance() -> void *"},
	 { "SoMFVec3s_getClassTypeId", _wrap_SoMFVec3s_getClassTypeId, METH_NOARGS, "SoMFVec3s_getClassTypeId() -> SoType"},
	 { "SoMFVec3s_getTypeId", _wrap_SoMFVec3s_getTypeId, METH_O, "SoMFVec3s_getTypeId(SoMFVec3s self) -> SoType"},
	 { "SoMFVec3s_copyFrom", _wrap_SoMFVec3s_copyFrom, METH_VARARGS, "SoMFVec3s_copyFrom(SoMFVec3s self, SoField field)"},
	 { "SoMFVec3s_isSame", _wrap_SoMFVec3s_isSame, METH_VARARGS, "SoMFVec3s_isSame(SoMFVec3s self, SoField field) -> SbBool"},
	 { "SoMFVec3s_getValues", _wrap_SoMFVec3s_getValues, METH_VARARGS, "SoMFVec3s_getValues(SoMFVec3s self, int const start) -> SbVec3s"},
	 { "SoMFVec3s_find", _wrap_SoMFVec3s_find, METH_VARARGS, "SoMFVec3s_find(SoMFVec3s self, SbVec3s value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec3s___eq__", _wrap_SoMFVec3s___eq__, METH_VARARGS, "SoMFVec3s___eq__(SoMFVec3s self, SoMFVec3s field) -> SbBool"},
	 { "SoMFVec3s___ne__", _wrap_SoMFVec3s___ne__, METH_VARARGS, "SoMFVec3s___ne__(SoMFVec3s self, SoMFVec3s field) -> SbBool"},
	 { "SoMFVec3s_startEditing", _wrap_SoMFVec3s_startEditing, METH_O, "SoMFVec3s_startEditing(SoMFVec3s self) -> SbVec3s"},
	 { "SoMFVec3s_finishEditing", _wrap_SoMFVec3s_finishEditing, METH_O, "SoMFVec3s_finishEditing(SoMFVec3s self)"},
	 { "SoMFVec3s_setValuesPointer", _wrap_SoMFVec3s_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec3s_setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)\n"
		"SoMFVec3s_setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)\n"
		"SoMFVec3s_setValuesPointer(SoMFVec3s self, int const num, short const * userdata)\n"
		"SoMFVec3s_setValuesPointer(SoMFVec3s self, int const num, short * userdata)\n"
		""},
	 { "SoMFVec3s_initClass", _wrap_SoMFVec3s_initClass, METH_NOARGS, "SoMFVec3s_initClass()"},
	 { "SoMFVec3s_setValues", _wrap_SoMFVec3s_setValues, METH_VARARGS, "\n"
		"SoMFVec3s_setValues(SoMFVec3s self, int const start, int const num, SbVec3s newvals)\n"
		"SoMFVec3s_setValues(SoMFVec3s self, int start, int num, short const [][3] xyz)\n"
		""},
	 { "SoMFVec3s_set1Value", _wrap_SoMFVec3s_set1Value, METH_VARARGS, "\n"
		"SoMFVec3s_set1Value(SoMFVec3s self, int const idx, SbVec3s value)\n"
		"SoMFVec3s_set1Value(SoMFVec3s self, int idx, short x, short y, short z)\n"
		"SoMFVec3s_set1Value(SoMFVec3s self, int idx, short const [3] xyz)\n"
		""},
	 { "SoMFVec3s_setValue", _wrap_SoMFVec3s_setValue, METH_VARARGS, "\n"
		"SoMFVec3s_setValue(SoMFVec3s self, SbVec3s value)\n"
		"SoMFVec3s_setValue(SoMFVec3s self, short x, short y, short z)\n"
		"SoMFVec3s_setValue(SoMFVec3s self, short const [3] xyz)\n"
		""},
	 { "SoMFVec3s_swigregister", SoMFVec3s_swigregister, METH_O, NULL},
	 { "SoMFVec3s_swiginit", SoMFVec3s_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec3i32", _wrap_new_SoMFVec3i32, METH_NOARGS, "new_SoMFVec3i32() -> SoMFVec3i32"},
	 { "delete_SoMFVec3i32", _wrap_delete_SoMFVec3i32, METH_O, "delete_SoMFVec3i32(SoMFVec3i32 self)"},
	 { "SoMFVec3i32_createInstance", _wrap_SoMFVec3i32_createInstance, METH_NOARGS, "SoMFVec3i32_createInstance() -> void *"},
	 { "SoMFVec3i32_getClassTypeId", _wrap_SoMFVec3i32_getClassTypeId, METH_NOARGS, "SoMFVec3i32_getClassTypeId() -> SoType"},
	 { "SoMFVec3i32_getTypeId", _wrap_SoMFVec3i32_getTypeId, METH_O, "SoMFVec3i32_getTypeId(SoMFVec3i32 self) -> SoType"},
	 { "SoMFVec3i32_copyFrom", _wrap_SoMFVec3i32_copyFrom, METH_VARARGS, "SoMFVec3i32_copyFrom(SoMFVec3i32 self, SoField field)"},
	 { "SoMFVec3i32_isSame", _wrap_SoMFVec3i32_isSame, METH_VARARGS, "SoMFVec3i32_isSame(SoMFVec3i32 self, SoField field) -> SbBool"},
	 { "SoMFVec3i32_getValues", _wrap_SoMFVec3i32_getValues, METH_VARARGS, "SoMFVec3i32_getValues(SoMFVec3i32 self, int const start) -> SbVec3i32"},
	 { "SoMFVec3i32_find", _wrap_SoMFVec3i32_find, METH_VARARGS, "SoMFVec3i32_find(SoMFVec3i32 self, SbVec3i32 value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec3i32___eq__", _wrap_SoMFVec3i32___eq__, METH_VARARGS, "SoMFVec3i32___eq__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"},
	 { "SoMFVec3i32___ne__", _wrap_SoMFVec3i32___ne__, METH_VARARGS, "SoMFVec3i32___ne__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"},
	 { "SoMFVec3i32_startEditing", _wrap_SoMFVec3i32_startEditing, METH_O, "SoMFVec3i32_startEditing(SoMFVec3i32 self) -> SbVec3i32"},
	 { "SoMFVec3i32_finishEditing", _wrap_SoMFVec3i32_finishEditing, METH_O, "SoMFVec3i32_finishEditing(SoMFVec3i32 self)"},
	 { "SoMFVec3i32_setValuesPointer", _wrap_SoMFVec3i32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec3i32_setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)\n"
		"SoMFVec3i32_setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)\n"
		"SoMFVec3i32_setValuesPointer(SoMFVec3i32 self, int const num, int32_t const * userdata)\n"
		"SoMFVec3i32_setValuesPointer(SoMFVec3i32 self, int const num, int32_t * userdata)\n"
		""},
	 { "SoMFVec3i32_initClass", _wrap_SoMFVec3i32_initClass, METH_NOARGS, "SoMFVec3i32_initClass()"},
	 { "SoMFVec3i32_setValues", _wrap_SoMFVec3i32_setValues, METH_VARARGS, "\n"
		"SoMFVec3i32_setValues(SoMFVec3i32 self, int const start, int const num, SbVec3i32 newvals)\n"
		"SoMFVec3i32_setValues(SoMFVec3i32 self, int start, int num, int32_t const [][3] xyz)\n"
		""},
	 { "SoMFVec3i32_set1Value", _wrap_SoMFVec3i32_set1Value, METH_VARARGS, "\n"
		"SoMFVec3i32_set1Value(SoMFVec3i32 self, int const idx, SbVec3i32 value)\n"
		"SoMFVec3i32_set1Value(SoMFVec3i32 self, int idx, int32_t x, int32_t y, int32_t z)\n"
		"SoMFVec3i32_set1Value(SoMFVec3i32 self, int idx, int32_t const [3] xyz)\n"
		""},
	 { "SoMFVec3i32_setValue", _wrap_SoMFVec3i32_setValue, METH_VARARGS, "\n"
		"SoMFVec3i32_setValue(SoMFVec3i32 self, SbVec3i32 value)\n"
		"SoMFVec3i32_setValue(SoMFVec3i32 self, int32_t x, int32_t y, int32_t z)\n"
		"SoMFVec3i32_setValue(SoMFVec3i32 self, int32_t const [3] xyz)\n"
		""},
	 { "SoMFVec3i32_swigregister", SoMFVec3i32_swigregister, METH_O, NULL},
	 { "SoMFVec3i32_swiginit", SoMFVec3i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec3d", _wrap_new_SoMFVec3d, METH_NOARGS, "new_SoMFVec3d() -> SoMFVec3d"},
	 { "delete_SoMFVec3d", _wrap_delete_SoMFVec3d, METH_O, "delete_SoMFVec3d(SoMFVec3d self)"},
	 { "SoMFVec3d_createInstance", _wrap_SoMFVec3d_createInstance, METH_NOARGS, "SoMFVec3d_createInstance() -> void *"},
	 { "SoMFVec3d_getClassTypeId", _wrap_SoMFVec3d_getClassTypeId, METH_NOARGS, "SoMFVec3d_getClassTypeId() -> SoType"},
	 { "SoMFVec3d_getTypeId", _wrap_SoMFVec3d_getTypeId, METH_O, "SoMFVec3d_getTypeId(SoMFVec3d self) -> SoType"},
	 { "SoMFVec3d_copyFrom", _wrap_SoMFVec3d_copyFrom, METH_VARARGS, "SoMFVec3d_copyFrom(SoMFVec3d self, SoField field)"},
	 { "SoMFVec3d_isSame", _wrap_SoMFVec3d_isSame, METH_VARARGS, "SoMFVec3d_isSame(SoMFVec3d self, SoField field) -> SbBool"},
	 { "SoMFVec3d_find", _wrap_SoMFVec3d_find, METH_VARARGS, "SoMFVec3d_find(SoMFVec3d self, SbVec3d value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec3d___eq__", _wrap_SoMFVec3d___eq__, METH_VARARGS, "SoMFVec3d___eq__(SoMFVec3d self, SoMFVec3d field) -> SbBool"},
	 { "SoMFVec3d___ne__", _wrap_SoMFVec3d___ne__, METH_VARARGS, "SoMFVec3d___ne__(SoMFVec3d self, SoMFVec3d field) -> SbBool"},
	 { "SoMFVec3d_startEditing", _wrap_SoMFVec3d_startEditing, METH_O, "SoMFVec3d_startEditing(SoMFVec3d self) -> SbVec3d"},
	 { "SoMFVec3d_finishEditing", _wrap_SoMFVec3d_finishEditing, METH_O, "SoMFVec3d_finishEditing(SoMFVec3d self)"},
	 { "SoMFVec3d_setValuesPointer", _wrap_SoMFVec3d_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec3d_setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)\n"
		"SoMFVec3d_setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)\n"
		"SoMFVec3d_setValuesPointer(SoMFVec3d self, int const num, double const * userdata)\n"
		"SoMFVec3d_setValuesPointer(SoMFVec3d self, int const num, double * userdata)\n"
		""},
	 { "SoMFVec3d_initClass", _wrap_SoMFVec3d_initClass, METH_NOARGS, "SoMFVec3d_initClass()"},
	 { "SoMFVec3d_setValues", _wrap_SoMFVec3d_setValues, METH_VARARGS, "\n"
		"SoMFVec3d_setValues(SoMFVec3d self, int const start, int const num, SbVec3d newvals)\n"
		"SoMFVec3d_setValues(SoMFVec3d self, int start, int num, double const [][3] xyz)\n"
		""},
	 { "SoMFVec3d_set1Value", _wrap_SoMFVec3d_set1Value, METH_VARARGS, "\n"
		"SoMFVec3d_set1Value(SoMFVec3d self, int const idx, SbVec3d value)\n"
		"SoMFVec3d_set1Value(SoMFVec3d self, int idx, double x, double y, double z)\n"
		"SoMFVec3d_set1Value(SoMFVec3d self, int idx, double const [3] xyz)\n"
		""},
	 { "SoMFVec3d___getitem__", _wrap_SoMFVec3d___getitem__, METH_VARARGS, "SoMFVec3d___getitem__(SoMFVec3d self, int i) -> SbVec3d"},
	 { "SoMFVec3d___setitem__", _wrap_SoMFVec3d___setitem__, METH_VARARGS, "SoMFVec3d___setitem__(SoMFVec3d self, int i, SbVec3d value)"},
	 { "SoMFVec3d_setValue", _wrap_SoMFVec3d_setValue, METH_VARARGS, "\n"
		"SoMFVec3d_setValue(SoMFVec3d self, SbVec3d value)\n"
		"SoMFVec3d_setValue(SoMFVec3d self, double x, double y, double z)\n"
		"SoMFVec3d_setValue(SoMFVec3d self, double const [3] xyz)\n"
		"SoMFVec3d_setValue(SoMFVec3d self, SoMFVec3d other)\n"
		""},
	 { "SoMFVec3d_getValues", _wrap_SoMFVec3d_getValues, METH_VARARGS, "SoMFVec3d_getValues(SoMFVec3d self, int i=0) -> SbVec3d"},
	 { "SoMFVec3d_swigregister", SoMFVec3d_swigregister, METH_O, NULL},
	 { "SoMFVec3d_swiginit", SoMFVec3d_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4b", _wrap_new_SoMFVec4b, METH_NOARGS, "new_SoMFVec4b() -> SoMFVec4b"},
	 { "delete_SoMFVec4b", _wrap_delete_SoMFVec4b, METH_O, "delete_SoMFVec4b(SoMFVec4b self)"},
	 { "SoMFVec4b_createInstance", _wrap_SoMFVec4b_createInstance, METH_NOARGS, "SoMFVec4b_createInstance() -> void *"},
	 { "SoMFVec4b_getClassTypeId", _wrap_SoMFVec4b_getClassTypeId, METH_NOARGS, "SoMFVec4b_getClassTypeId() -> SoType"},
	 { "SoMFVec4b_getTypeId", _wrap_SoMFVec4b_getTypeId, METH_O, "SoMFVec4b_getTypeId(SoMFVec4b self) -> SoType"},
	 { "SoMFVec4b_copyFrom", _wrap_SoMFVec4b_copyFrom, METH_VARARGS, "SoMFVec4b_copyFrom(SoMFVec4b self, SoField field)"},
	 { "SoMFVec4b_isSame", _wrap_SoMFVec4b_isSame, METH_VARARGS, "SoMFVec4b_isSame(SoMFVec4b self, SoField field) -> SbBool"},
	 { "SoMFVec4b_getValues", _wrap_SoMFVec4b_getValues, METH_VARARGS, "SoMFVec4b_getValues(SoMFVec4b self, int const start) -> SbVec4b"},
	 { "SoMFVec4b_find", _wrap_SoMFVec4b_find, METH_VARARGS, "SoMFVec4b_find(SoMFVec4b self, SbVec4b value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4b___eq__", _wrap_SoMFVec4b___eq__, METH_VARARGS, "SoMFVec4b___eq__(SoMFVec4b self, SoMFVec4b field) -> SbBool"},
	 { "SoMFVec4b___ne__", _wrap_SoMFVec4b___ne__, METH_VARARGS, "SoMFVec4b___ne__(SoMFVec4b self, SoMFVec4b field) -> SbBool"},
	 { "SoMFVec4b_startEditing", _wrap_SoMFVec4b_startEditing, METH_O, "SoMFVec4b_startEditing(SoMFVec4b self) -> SbVec4b"},
	 { "SoMFVec4b_finishEditing", _wrap_SoMFVec4b_finishEditing, METH_O, "SoMFVec4b_finishEditing(SoMFVec4b self)"},
	 { "SoMFVec4b_setValuesPointer", _wrap_SoMFVec4b_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4b_setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)\n"
		"SoMFVec4b_setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)\n"
		"SoMFVec4b_setValuesPointer(SoMFVec4b self, int const num, int8_t const * userdata)\n"
		"SoMFVec4b_setValuesPointer(SoMFVec4b self, int const num, int8_t * userdata)\n"
		""},
	 { "SoMFVec4b_initClass", _wrap_SoMFVec4b_initClass, METH_NOARGS, "SoMFVec4b_initClass()"},
	 { "SoMFVec4b_setValues", _wrap_SoMFVec4b_setValues, METH_VARARGS, "\n"
		"SoMFVec4b_setValues(SoMFVec4b self, int const start, int const num, SbVec4b newvals)\n"
		"SoMFVec4b_setValues(SoMFVec4b self, int start, int num, int8_t const [][4] xyzw)\n"
		""},
	 { "SoMFVec4b_set1Value", _wrap_SoMFVec4b_set1Value, METH_VARARGS, "\n"
		"SoMFVec4b_set1Value(SoMFVec4b self, int const idx, SbVec4b value)\n"
		"SoMFVec4b_set1Value(SoMFVec4b self, int idx, int8_t x, int8_t y, int8_t z, int8_t w)\n"
		"SoMFVec4b_set1Value(SoMFVec4b self, int idx, int8_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4b_setValue", _wrap_SoMFVec4b_setValue, METH_VARARGS, "\n"
		"SoMFVec4b_setValue(SoMFVec4b self, SbVec4b value)\n"
		"SoMFVec4b_setValue(SoMFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)\n"
		"SoMFVec4b_setValue(SoMFVec4b self, int8_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4b_swigregister", SoMFVec4b_swigregister, METH_O, NULL},
	 { "SoMFVec4b_swiginit", SoMFVec4b_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4ub", _wrap_new_SoMFVec4ub, METH_NOARGS, "new_SoMFVec4ub() -> SoMFVec4ub"},
	 { "delete_SoMFVec4ub", _wrap_delete_SoMFVec4ub, METH_O, "delete_SoMFVec4ub(SoMFVec4ub self)"},
	 { "SoMFVec4ub_createInstance", _wrap_SoMFVec4ub_createInstance, METH_NOARGS, "SoMFVec4ub_createInstance() -> void *"},
	 { "SoMFVec4ub_getClassTypeId", _wrap_SoMFVec4ub_getClassTypeId, METH_NOARGS, "SoMFVec4ub_getClassTypeId() -> SoType"},
	 { "SoMFVec4ub_getTypeId", _wrap_SoMFVec4ub_getTypeId, METH_O, "SoMFVec4ub_getTypeId(SoMFVec4ub self) -> SoType"},
	 { "SoMFVec4ub_copyFrom", _wrap_SoMFVec4ub_copyFrom, METH_VARARGS, "SoMFVec4ub_copyFrom(SoMFVec4ub self, SoField field)"},
	 { "SoMFVec4ub_isSame", _wrap_SoMFVec4ub_isSame, METH_VARARGS, "SoMFVec4ub_isSame(SoMFVec4ub self, SoField field) -> SbBool"},
	 { "SoMFVec4ub_getValues", _wrap_SoMFVec4ub_getValues, METH_VARARGS, "SoMFVec4ub_getValues(SoMFVec4ub self, int const start) -> SbVec4ub"},
	 { "SoMFVec4ub_find", _wrap_SoMFVec4ub_find, METH_VARARGS, "SoMFVec4ub_find(SoMFVec4ub self, SbVec4ub value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4ub___eq__", _wrap_SoMFVec4ub___eq__, METH_VARARGS, "SoMFVec4ub___eq__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"},
	 { "SoMFVec4ub___ne__", _wrap_SoMFVec4ub___ne__, METH_VARARGS, "SoMFVec4ub___ne__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"},
	 { "SoMFVec4ub_startEditing", _wrap_SoMFVec4ub_startEditing, METH_O, "SoMFVec4ub_startEditing(SoMFVec4ub self) -> SbVec4ub"},
	 { "SoMFVec4ub_finishEditing", _wrap_SoMFVec4ub_finishEditing, METH_O, "SoMFVec4ub_finishEditing(SoMFVec4ub self)"},
	 { "SoMFVec4ub_setValuesPointer", _wrap_SoMFVec4ub_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4ub_setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)\n"
		"SoMFVec4ub_setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)\n"
		"SoMFVec4ub_setValuesPointer(SoMFVec4ub self, int const num, uint8_t const * userdata)\n"
		"SoMFVec4ub_setValuesPointer(SoMFVec4ub self, int const num, uint8_t * userdata)\n"
		""},
	 { "SoMFVec4ub_initClass", _wrap_SoMFVec4ub_initClass, METH_NOARGS, "SoMFVec4ub_initClass()"},
	 { "SoMFVec4ub_setValues", _wrap_SoMFVec4ub_setValues, METH_VARARGS, "\n"
		"SoMFVec4ub_setValues(SoMFVec4ub self, int const start, int const num, SbVec4ub newvals)\n"
		"SoMFVec4ub_setValues(SoMFVec4ub self, int start, int num, uint8_t const [][4] xyzw)\n"
		""},
	 { "SoMFVec4ub_set1Value", _wrap_SoMFVec4ub_set1Value, METH_VARARGS, "\n"
		"SoMFVec4ub_set1Value(SoMFVec4ub self, int const idx, SbVec4ub value)\n"
		"SoMFVec4ub_set1Value(SoMFVec4ub self, int idx, uint8_t x, uint8_t y, uint8_t z, uint8_t w)\n"
		"SoMFVec4ub_set1Value(SoMFVec4ub self, int idx, uint8_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4ub_setValue", _wrap_SoMFVec4ub_setValue, METH_VARARGS, "\n"
		"SoMFVec4ub_setValue(SoMFVec4ub self, SbVec4ub value)\n"
		"SoMFVec4ub_setValue(SoMFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)\n"
		"SoMFVec4ub_setValue(SoMFVec4ub self, uint8_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4ub_swigregister", SoMFVec4ub_swigregister, METH_O, NULL},
	 { "SoMFVec4ub_swiginit", SoMFVec4ub_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4s", _wrap_new_SoMFVec4s, METH_NOARGS, "new_SoMFVec4s() -> SoMFVec4s"},
	 { "delete_SoMFVec4s", _wrap_delete_SoMFVec4s, METH_O, "delete_SoMFVec4s(SoMFVec4s self)"},
	 { "SoMFVec4s_createInstance", _wrap_SoMFVec4s_createInstance, METH_NOARGS, "SoMFVec4s_createInstance() -> void *"},
	 { "SoMFVec4s_getClassTypeId", _wrap_SoMFVec4s_getClassTypeId, METH_NOARGS, "SoMFVec4s_getClassTypeId() -> SoType"},
	 { "SoMFVec4s_getTypeId", _wrap_SoMFVec4s_getTypeId, METH_O, "SoMFVec4s_getTypeId(SoMFVec4s self) -> SoType"},
	 { "SoMFVec4s_copyFrom", _wrap_SoMFVec4s_copyFrom, METH_VARARGS, "SoMFVec4s_copyFrom(SoMFVec4s self, SoField field)"},
	 { "SoMFVec4s_isSame", _wrap_SoMFVec4s_isSame, METH_VARARGS, "SoMFVec4s_isSame(SoMFVec4s self, SoField field) -> SbBool"},
	 { "SoMFVec4s_getValues", _wrap_SoMFVec4s_getValues, METH_VARARGS, "SoMFVec4s_getValues(SoMFVec4s self, int const start) -> SbVec4s"},
	 { "SoMFVec4s_find", _wrap_SoMFVec4s_find, METH_VARARGS, "SoMFVec4s_find(SoMFVec4s self, SbVec4s value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4s___eq__", _wrap_SoMFVec4s___eq__, METH_VARARGS, "SoMFVec4s___eq__(SoMFVec4s self, SoMFVec4s field) -> SbBool"},
	 { "SoMFVec4s___ne__", _wrap_SoMFVec4s___ne__, METH_VARARGS, "SoMFVec4s___ne__(SoMFVec4s self, SoMFVec4s field) -> SbBool"},
	 { "SoMFVec4s_startEditing", _wrap_SoMFVec4s_startEditing, METH_O, "SoMFVec4s_startEditing(SoMFVec4s self) -> SbVec4s"},
	 { "SoMFVec4s_finishEditing", _wrap_SoMFVec4s_finishEditing, METH_O, "SoMFVec4s_finishEditing(SoMFVec4s self)"},
	 { "SoMFVec4s_setValuesPointer", _wrap_SoMFVec4s_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4s_setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)\n"
		"SoMFVec4s_setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)\n"
		"SoMFVec4s_setValuesPointer(SoMFVec4s self, int const num, short const * userdata)\n"
		"SoMFVec4s_setValuesPointer(SoMFVec4s self, int const num, short * userdata)\n"
		""},
	 { "SoMFVec4s_initClass", _wrap_SoMFVec4s_initClass, METH_NOARGS, "SoMFVec4s_initClass()"},
	 { "SoMFVec4s_setValues", _wrap_SoMFVec4s_setValues, METH_VARARGS, "\n"
		"SoMFVec4s_setValues(SoMFVec4s self, int const start, int const num, SbVec4s newvals)\n"
		"SoMFVec4s_setValues(SoMFVec4s self, int start, int num, short const [][4] xyzw)\n"
		""},
	 { "SoMFVec4s_set1Value", _wrap_SoMFVec4s_set1Value, METH_VARARGS, "\n"
		"SoMFVec4s_set1Value(SoMFVec4s self, int const idx, SbVec4s value)\n"
		"SoMFVec4s_set1Value(SoMFVec4s self, int idx, short x, short y, short z, short w)\n"
		"SoMFVec4s_set1Value(SoMFVec4s self, int idx, short const [4] xyzw)\n"
		""},
	 { "SoMFVec4s_setValue", _wrap_SoMFVec4s_setValue, METH_VARARGS, "\n"
		"SoMFVec4s_setValue(SoMFVec4s self, SbVec4s value)\n"
		"SoMFVec4s_setValue(SoMFVec4s self, short x, short y, short z, short w)\n"
		"SoMFVec4s_setValue(SoMFVec4s self, short const [4] xyzw)\n"
		""},
	 { "SoMFVec4s_swigregister", SoMFVec4s_swigregister, METH_O, NULL},
	 { "SoMFVec4s_swiginit", SoMFVec4s_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4us", _wrap_new_SoMFVec4us, METH_NOARGS, "new_SoMFVec4us() -> SoMFVec4us"},
	 { "delete_SoMFVec4us", _wrap_delete_SoMFVec4us, METH_O, "delete_SoMFVec4us(SoMFVec4us self)"},
	 { "SoMFVec4us_createInstance", _wrap_SoMFVec4us_createInstance, METH_NOARGS, "SoMFVec4us_createInstance() -> void *"},
	 { "SoMFVec4us_getClassTypeId", _wrap_SoMFVec4us_getClassTypeId, METH_NOARGS, "SoMFVec4us_getClassTypeId() -> SoType"},
	 { "SoMFVec4us_getTypeId", _wrap_SoMFVec4us_getTypeId, METH_O, "SoMFVec4us_getTypeId(SoMFVec4us self) -> SoType"},
	 { "SoMFVec4us_copyFrom", _wrap_SoMFVec4us_copyFrom, METH_VARARGS, "SoMFVec4us_copyFrom(SoMFVec4us self, SoField field)"},
	 { "SoMFVec4us_isSame", _wrap_SoMFVec4us_isSame, METH_VARARGS, "SoMFVec4us_isSame(SoMFVec4us self, SoField field) -> SbBool"},
	 { "SoMFVec4us_getValues", _wrap_SoMFVec4us_getValues, METH_VARARGS, "SoMFVec4us_getValues(SoMFVec4us self, int const start) -> SbVec4us"},
	 { "SoMFVec4us_find", _wrap_SoMFVec4us_find, METH_VARARGS, "SoMFVec4us_find(SoMFVec4us self, SbVec4us value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4us___eq__", _wrap_SoMFVec4us___eq__, METH_VARARGS, "SoMFVec4us___eq__(SoMFVec4us self, SoMFVec4us field) -> SbBool"},
	 { "SoMFVec4us___ne__", _wrap_SoMFVec4us___ne__, METH_VARARGS, "SoMFVec4us___ne__(SoMFVec4us self, SoMFVec4us field) -> SbBool"},
	 { "SoMFVec4us_startEditing", _wrap_SoMFVec4us_startEditing, METH_O, "SoMFVec4us_startEditing(SoMFVec4us self) -> SbVec4us"},
	 { "SoMFVec4us_finishEditing", _wrap_SoMFVec4us_finishEditing, METH_O, "SoMFVec4us_finishEditing(SoMFVec4us self)"},
	 { "SoMFVec4us_setValuesPointer", _wrap_SoMFVec4us_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4us_setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)\n"
		"SoMFVec4us_setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)\n"
		"SoMFVec4us_setValuesPointer(SoMFVec4us self, int const num, unsigned short const * userdata)\n"
		"SoMFVec4us_setValuesPointer(SoMFVec4us self, int const num, unsigned short * userdata)\n"
		""},
	 { "SoMFVec4us_initClass", _wrap_SoMFVec4us_initClass, METH_NOARGS, "SoMFVec4us_initClass()"},
	 { "SoMFVec4us_setValues", _wrap_SoMFVec4us_setValues, METH_VARARGS, "\n"
		"SoMFVec4us_setValues(SoMFVec4us self, int const start, int const num, SbVec4us newvals)\n"
		"SoMFVec4us_setValues(SoMFVec4us self, int start, int num, unsigned short const [][4] xyzw)\n"
		""},
	 { "SoMFVec4us_set1Value", _wrap_SoMFVec4us_set1Value, METH_VARARGS, "\n"
		"SoMFVec4us_set1Value(SoMFVec4us self, int const idx, SbVec4us value)\n"
		"SoMFVec4us_set1Value(SoMFVec4us self, int idx, unsigned short x, unsigned short y, unsigned short z, unsigned short w)\n"
		"SoMFVec4us_set1Value(SoMFVec4us self, int idx, unsigned short const [4] xyzw)\n"
		""},
	 { "SoMFVec4us_setValue", _wrap_SoMFVec4us_setValue, METH_VARARGS, "\n"
		"SoMFVec4us_setValue(SoMFVec4us self, SbVec4us value)\n"
		"SoMFVec4us_setValue(SoMFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)\n"
		"SoMFVec4us_setValue(SoMFVec4us self, unsigned short const [4] xyzw)\n"
		""},
	 { "SoMFVec4us_swigregister", SoMFVec4us_swigregister, METH_O, NULL},
	 { "SoMFVec4us_swiginit", SoMFVec4us_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4i32", _wrap_new_SoMFVec4i32, METH_NOARGS, "new_SoMFVec4i32() -> SoMFVec4i32"},
	 { "delete_SoMFVec4i32", _wrap_delete_SoMFVec4i32, METH_O, "delete_SoMFVec4i32(SoMFVec4i32 self)"},
	 { "SoMFVec4i32_createInstance", _wrap_SoMFVec4i32_createInstance, METH_NOARGS, "SoMFVec4i32_createInstance() -> void *"},
	 { "SoMFVec4i32_getClassTypeId", _wrap_SoMFVec4i32_getClassTypeId, METH_NOARGS, "SoMFVec4i32_getClassTypeId() -> SoType"},
	 { "SoMFVec4i32_getTypeId", _wrap_SoMFVec4i32_getTypeId, METH_O, "SoMFVec4i32_getTypeId(SoMFVec4i32 self) -> SoType"},
	 { "SoMFVec4i32_copyFrom", _wrap_SoMFVec4i32_copyFrom, METH_VARARGS, "SoMFVec4i32_copyFrom(SoMFVec4i32 self, SoField field)"},
	 { "SoMFVec4i32_isSame", _wrap_SoMFVec4i32_isSame, METH_VARARGS, "SoMFVec4i32_isSame(SoMFVec4i32 self, SoField field) -> SbBool"},
	 { "SoMFVec4i32_getValues", _wrap_SoMFVec4i32_getValues, METH_VARARGS, "SoMFVec4i32_getValues(SoMFVec4i32 self, int const start) -> SbVec4i32"},
	 { "SoMFVec4i32_find", _wrap_SoMFVec4i32_find, METH_VARARGS, "SoMFVec4i32_find(SoMFVec4i32 self, SbVec4i32 value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4i32___eq__", _wrap_SoMFVec4i32___eq__, METH_VARARGS, "SoMFVec4i32___eq__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"},
	 { "SoMFVec4i32___ne__", _wrap_SoMFVec4i32___ne__, METH_VARARGS, "SoMFVec4i32___ne__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"},
	 { "SoMFVec4i32_startEditing", _wrap_SoMFVec4i32_startEditing, METH_O, "SoMFVec4i32_startEditing(SoMFVec4i32 self) -> SbVec4i32"},
	 { "SoMFVec4i32_finishEditing", _wrap_SoMFVec4i32_finishEditing, METH_O, "SoMFVec4i32_finishEditing(SoMFVec4i32 self)"},
	 { "SoMFVec4i32_setValuesPointer", _wrap_SoMFVec4i32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4i32_setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)\n"
		"SoMFVec4i32_setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)\n"
		"SoMFVec4i32_setValuesPointer(SoMFVec4i32 self, int const num, int32_t const * userdata)\n"
		"SoMFVec4i32_setValuesPointer(SoMFVec4i32 self, int const num, int32_t * userdata)\n"
		""},
	 { "SoMFVec4i32_initClass", _wrap_SoMFVec4i32_initClass, METH_NOARGS, "SoMFVec4i32_initClass()"},
	 { "SoMFVec4i32_setValues", _wrap_SoMFVec4i32_setValues, METH_VARARGS, "\n"
		"SoMFVec4i32_setValues(SoMFVec4i32 self, int const start, int const num, SbVec4i32 newvals)\n"
		"SoMFVec4i32_setValues(SoMFVec4i32 self, int start, int num, int32_t const [][4] xyzw)\n"
		""},
	 { "SoMFVec4i32_set1Value", _wrap_SoMFVec4i32_set1Value, METH_VARARGS, "\n"
		"SoMFVec4i32_set1Value(SoMFVec4i32 self, int const idx, SbVec4i32 value)\n"
		"SoMFVec4i32_set1Value(SoMFVec4i32 self, int idx, int32_t x, int32_t y, int32_t z, int32_t w)\n"
		"SoMFVec4i32_set1Value(SoMFVec4i32 self, int idx, int32_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4i32_setValue", _wrap_SoMFVec4i32_setValue, METH_VARARGS, "\n"
		"SoMFVec4i32_setValue(SoMFVec4i32 self, SbVec4i32 value)\n"
		"SoMFVec4i32_setValue(SoMFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)\n"
		"SoMFVec4i32_setValue(SoMFVec4i32 self, int32_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4i32_swigregister", SoMFVec4i32_swigregister, METH_O, NULL},
	 { "SoMFVec4i32_swiginit", SoMFVec4i32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4ui32", _wrap_new_SoMFVec4ui32, METH_NOARGS, "new_SoMFVec4ui32() -> SoMFVec4ui32"},
	 { "delete_SoMFVec4ui32", _wrap_delete_SoMFVec4ui32, METH_O, "delete_SoMFVec4ui32(SoMFVec4ui32 self)"},
	 { "SoMFVec4ui32_createInstance", _wrap_SoMFVec4ui32_createInstance, METH_NOARGS, "SoMFVec4ui32_createInstance() -> void *"},
	 { "SoMFVec4ui32_getClassTypeId", _wrap_SoMFVec4ui32_getClassTypeId, METH_NOARGS, "SoMFVec4ui32_getClassTypeId() -> SoType"},
	 { "SoMFVec4ui32_getTypeId", _wrap_SoMFVec4ui32_getTypeId, METH_O, "SoMFVec4ui32_getTypeId(SoMFVec4ui32 self) -> SoType"},
	 { "SoMFVec4ui32_copyFrom", _wrap_SoMFVec4ui32_copyFrom, METH_VARARGS, "SoMFVec4ui32_copyFrom(SoMFVec4ui32 self, SoField field)"},
	 { "SoMFVec4ui32_isSame", _wrap_SoMFVec4ui32_isSame, METH_VARARGS, "SoMFVec4ui32_isSame(SoMFVec4ui32 self, SoField field) -> SbBool"},
	 { "SoMFVec4ui32_getValues", _wrap_SoMFVec4ui32_getValues, METH_VARARGS, "SoMFVec4ui32_getValues(SoMFVec4ui32 self, int const start) -> SbVec4ui32"},
	 { "SoMFVec4ui32_find", _wrap_SoMFVec4ui32_find, METH_VARARGS, "SoMFVec4ui32_find(SoMFVec4ui32 self, SbVec4ui32 value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4ui32___eq__", _wrap_SoMFVec4ui32___eq__, METH_VARARGS, "SoMFVec4ui32___eq__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"},
	 { "SoMFVec4ui32___ne__", _wrap_SoMFVec4ui32___ne__, METH_VARARGS, "SoMFVec4ui32___ne__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"},
	 { "SoMFVec4ui32_startEditing", _wrap_SoMFVec4ui32_startEditing, METH_O, "SoMFVec4ui32_startEditing(SoMFVec4ui32 self) -> SbVec4ui32"},
	 { "SoMFVec4ui32_finishEditing", _wrap_SoMFVec4ui32_finishEditing, METH_O, "SoMFVec4ui32_finishEditing(SoMFVec4ui32 self)"},
	 { "SoMFVec4ui32_setValuesPointer", _wrap_SoMFVec4ui32_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4ui32_setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)\n"
		"SoMFVec4ui32_setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)\n"
		"SoMFVec4ui32_setValuesPointer(SoMFVec4ui32 self, int const num, uint32_t const * userdata)\n"
		"SoMFVec4ui32_setValuesPointer(SoMFVec4ui32 self, int const num, uint32_t * userdata)\n"
		""},
	 { "SoMFVec4ui32_initClass", _wrap_SoMFVec4ui32_initClass, METH_NOARGS, "SoMFVec4ui32_initClass()"},
	 { "SoMFVec4ui32_setValues", _wrap_SoMFVec4ui32_setValues, METH_VARARGS, "\n"
		"SoMFVec4ui32_setValues(SoMFVec4ui32 self, int const start, int const num, SbVec4ui32 newvals)\n"
		"SoMFVec4ui32_setValues(SoMFVec4ui32 self, int start, int num, uint32_t const [][4] xyzw)\n"
		""},
	 { "SoMFVec4ui32_set1Value", _wrap_SoMFVec4ui32_set1Value, METH_VARARGS, "\n"
		"SoMFVec4ui32_set1Value(SoMFVec4ui32 self, int const idx, SbVec4ui32 value)\n"
		"SoMFVec4ui32_set1Value(SoMFVec4ui32 self, int idx, uint32_t x, uint32_t y, uint32_t z, uint32_t w)\n"
		"SoMFVec4ui32_set1Value(SoMFVec4ui32 self, int idx, uint32_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4ui32_setValue", _wrap_SoMFVec4ui32_setValue, METH_VARARGS, "\n"
		"SoMFVec4ui32_setValue(SoMFVec4ui32 self, SbVec4ui32 value)\n"
		"SoMFVec4ui32_setValue(SoMFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)\n"
		"SoMFVec4ui32_setValue(SoMFVec4ui32 self, uint32_t const [4] xyzw)\n"
		""},
	 { "SoMFVec4ui32_swigregister", SoMFVec4ui32_swigregister, METH_O, NULL},
	 { "SoMFVec4ui32_swiginit", SoMFVec4ui32_swiginit, METH_VARARGS, NULL},
	 { "new_SoMFVec4d", _wrap_new_SoMFVec4d, METH_NOARGS, "new_SoMFVec4d() -> SoMFVec4d"},
	 { "delete_SoMFVec4d", _wrap_delete_SoMFVec4d, METH_O, "delete_SoMFVec4d(SoMFVec4d self)"},
	 { "SoMFVec4d_createInstance", _wrap_SoMFVec4d_createInstance, METH_NOARGS, "SoMFVec4d_createInstance() -> void *"},
	 { "SoMFVec4d_getClassTypeId", _wrap_SoMFVec4d_getClassTypeId, METH_NOARGS, "SoMFVec4d_getClassTypeId() -> SoType"},
	 { "SoMFVec4d_getTypeId", _wrap_SoMFVec4d_getTypeId, METH_O, "SoMFVec4d_getTypeId(SoMFVec4d self) -> SoType"},
	 { "SoMFVec4d_copyFrom", _wrap_SoMFVec4d_copyFrom, METH_VARARGS, "SoMFVec4d_copyFrom(SoMFVec4d self, SoField field)"},
	 { "SoMFVec4d_isSame", _wrap_SoMFVec4d_isSame, METH_VARARGS, "SoMFVec4d_isSame(SoMFVec4d self, SoField field) -> SbBool"},
	 { "SoMFVec4d_getValues", _wrap_SoMFVec4d_getValues, METH_VARARGS, "SoMFVec4d_getValues(SoMFVec4d self, int const start) -> SbVec4d"},
	 { "SoMFVec4d_find", _wrap_SoMFVec4d_find, METH_VARARGS, "SoMFVec4d_find(SoMFVec4d self, SbVec4d value, SbBool addifnotfound=0) -> int"},
	 { "SoMFVec4d___eq__", _wrap_SoMFVec4d___eq__, METH_VARARGS, "SoMFVec4d___eq__(SoMFVec4d self, SoMFVec4d field) -> SbBool"},
	 { "SoMFVec4d___ne__", _wrap_SoMFVec4d___ne__, METH_VARARGS, "SoMFVec4d___ne__(SoMFVec4d self, SoMFVec4d field) -> SbBool"},
	 { "SoMFVec4d_startEditing", _wrap_SoMFVec4d_startEditing, METH_O, "SoMFVec4d_startEditing(SoMFVec4d self) -> SbVec4d"},
	 { "SoMFVec4d_finishEditing", _wrap_SoMFVec4d_finishEditing, METH_O, "SoMFVec4d_finishEditing(SoMFVec4d self)"},
	 { "SoMFVec4d_setValuesPointer", _wrap_SoMFVec4d_setValuesPointer, METH_VARARGS, "\n"
		"SoMFVec4d_setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)\n"
		"SoMFVec4d_setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)\n"
		"SoMFVec4d_setValuesPointer(SoMFVec4d self, int const num, double const * userdata)\n"
		"SoMFVec4d_setValuesPointer(SoMFVec4d self, int const num, double * userdata)\n"
		""},
	 { "SoMFVec4d_initClass", _wrap_SoMFVec4d_initClass, METH_NOARGS, "SoMFVec4d_initClass()"},
	 { "SoMFVec4d_setValues", _wrap_SoMFVec4d_setValues, METH_VARARGS, "\n"
		"SoMFVec4d_setValues(SoMFVec4d self, int const start, int const num, SbVec4d newvals)\n"
		"SoMFVec4d_setValues(SoMFVec4d self, int start, int num, double const [][4] xyzw)\n"
		""},
	 { "SoMFVec4d_set1Value", _wrap_SoMFVec4d_set1Value, METH_VARARGS, "\n"
		"SoMFVec4d_set1Value(SoMFVec4d self, int const idx, SbVec4d value)\n"
		"SoMFVec4d_set1Value(SoMFVec4d self, int idx, double x, double y, double z, double w)\n"
		"SoMFVec4d_set1Value(SoMFVec4d self, int idx, double const [4] xyzw)\n"
		""},
	 { "SoMFVec4d_setValue", _wrap_SoMFVec4d_setValue, METH_VARARGS, "\n"
		"SoMFVec4d_setValue(SoMFVec4d self, SbVec4d value)\n"
		"SoMFVec4d_setValue(SoMFVec4d self, double x, double y, double z, double w)\n"
		"SoMFVec4d_setValue(SoMFVec4d self, double const [4] xyzw)\n"
		""},
	 { "SoMFVec4d_swigregister", SoMFVec4d_swigregister, METH_O, NULL},
	 { "SoMFVec4d_swiginit", SoMFVec4d_swiginit, METH_VARARGS, NULL},
	 { "new_SbStringList", _wrap_new_SbStringList, METH_VARARGS, "\n"
		"SbStringList()\n"
		"new_SbStringList(int const sizehint) -> SbStringList\n"
		""},
	 { "SbStringList_append", _wrap_SbStringList_append, METH_VARARGS, "SbStringList_append(SbStringList self, SbString string)"},
	 { "SbStringList_find", _wrap_SbStringList_find, METH_VARARGS, "SbStringList_find(SbStringList self, SbString string) -> int"},
	 { "SbStringList_insert", _wrap_SbStringList_insert, METH_VARARGS, "SbStringList_insert(SbStringList self, SbString string, int insertbefore)"},
	 { "SbStringList_getArrayPtr", _wrap_SbStringList_getArrayPtr, METH_O, "SbStringList_getArrayPtr(SbStringList self) -> SbString const **"},
	 { "SbStringList___setitem__", _wrap_SbStringList___setitem__, METH_VARARGS, "SbStringList___setitem__(SbStringList self, int const i, SbString value)"},
	 { "SbStringList___getitem__", _wrap_SbStringList___getitem__, METH_VARARGS, "SbStringList___getitem__(SbStringList self, int i) -> SbString"},
	 { "SbStringList_get", _wrap_SbStringList_get, METH_VARARGS, "SbStringList_get(SbStringList self, int const i) -> SbString"},
	 { "delete_SbStringList", _wrap_delete_SbStringList, METH_O, "delete_SbStringList(SbStringList self)"},
	 { "SbStringList_swigregister", SbStringList_swigregister, METH_O, NULL},
	 { "SbStringList_swiginit", SbStringList_swiginit, METH_VARARGS, NULL},
	 { "new_SbVec3fList", _wrap_new_SbVec3fList, METH_NOARGS, "new_SbVec3fList() -> SbVec3fList"},
	 { "delete_SbVec3fList", _wrap_delete_SbVec3fList, METH_O, "delete_SbVec3fList(SbVec3fList self)"},
	 { "SbVec3fList_append", _wrap_SbVec3fList_append, METH_VARARGS, "SbVec3fList_append(SbVec3fList self, SbVec3f item)"},
	 { "SbVec3fList_insert", _wrap_SbVec3fList_insert, METH_VARARGS, "SbVec3fList_insert(SbVec3fList self, SbVec3f item, int const insertbefore)"},
	 { "SbVec3fList___setitem__", _wrap_SbVec3fList___setitem__, METH_VARARGS, "SbVec3fList___setitem__(SbVec3fList self, int const i, SbVec3f value)"},
	 { "SbVec3fList___getitem__", _wrap_SbVec3fList___getitem__, METH_VARARGS, "SbVec3fList___getitem__(SbVec3fList self, int i) -> SbVec3f"},
	 { "SbVec3fList_get", _wrap_SbVec3fList_get, METH_VARARGS, "SbVec3fList_get(SbVec3fList self, int const i) -> SbVec3f"},
	 { "SbVec3fList_swigregister", SbVec3fList_swigregister, METH_O, NULL},
	 { "SbVec3fList_swiginit", SbVec3fList_swiginit, METH_VARARGS, NULL},
	 { "SoLockManager_SetUnlockString", _wrap_SoLockManager_SetUnlockString, METH_O, "SoLockManager_SetUnlockString(char * unlockstr)"},
	 { "SoLockManager_GetUnlockString", _wrap_SoLockManager_GetUnlockString, METH_NOARGS, "SoLockManager_GetUnlockString() -> char *"},
	 { "new_SoLockManager", _wrap_new_SoLockManager, METH_NOARGS, "new_SoLockManager() -> SoLockManager"},
	 { "delete_SoLockManager", _wrap_delete_SoLockManager, METH_O, "delete_SoLockManager(SoLockManager self)"},
	 { "SoLockManager_swigregister", SoLockManager_swigregister, METH_O, NULL},
	 { "SoLockManager_swiginit", SoLockManager_swiginit, METH_VARARGS, NULL},
	 { "SoTransform_getClassTypeId", _wrap_SoTransform_getClassTypeId, METH_NOARGS, "SoTransform_getClassTypeId() -> SoType"},
	 { "SoTransform_getTypeId", _wrap_SoTransform_getTypeId, METH_O, "SoTransform_getTypeId(SoTransform self) -> SoType"},
	 { "SoTransform_initClass", _wrap_SoTransform_initClass, METH_NOARGS, "SoTransform_initClass()"},
	 { "new_SoTransform", _wrap_new_SoTransform, METH_NOARGS, "new_SoTransform() -> SoTransform"},
	 { "SoTransform_translation_set", _wrap_SoTransform_translation_set, METH_VARARGS, "SoTransform_translation_set(SoTransform self, SoSFVec3f translation)"},
	 { "SoTransform_translation_get", _wrap_SoTransform_translation_get, METH_O, "SoTransform_translation_get(SoTransform self) -> SoSFVec3f"},
	 { "SoTransform_rotation_set", _wrap_SoTransform_rotation_set, METH_VARARGS, "SoTransform_rotation_set(SoTransform self, SoSFRotation rotation)"},
	 { "SoTransform_rotation_get", _wrap_SoTransform_rotation_get, METH_O, "SoTransform_rotation_get(SoTransform self) -> SoSFRotation"},
	 { "SoTransform_scaleFactor_set", _wrap_SoTransform_scaleFactor_set, METH_VARARGS, "SoTransform_scaleFactor_set(SoTransform self, SoSFVec3f scaleFactor)"},
	 { "SoTransform_scaleFactor_get", _wrap_SoTransform_scaleFactor_get, METH_O, "SoTransform_scaleFactor_get(SoTransform self) -> SoSFVec3f"},
	 { "SoTransform_scaleOrientation_set", _wrap_SoTransform_scaleOrientation_set, METH_VARARGS, "SoTransform_scaleOrientation_set(SoTransform self, SoSFRotation scaleOrientation)"},
	 { "SoTransform_scaleOrientation_get", _wrap_SoTransform_scaleOrientation_get, METH_O, "SoTransform_scaleOrientation_get(SoTransform self) -> SoSFRotation"},
	 { "SoTransform_center_set", _wrap_SoTransform_center_set, METH_VARARGS, "SoTransform_center_set(SoTransform self, SoSFVec3f center)"},
	 { "SoTransform_center_get", _wrap_SoTransform_center_get, METH_O, "SoTransform_center_get(SoTransform self) -> SoSFVec3f"},
	 { "SoTransform_pointAt", _wrap_SoTransform_pointAt, METH_VARARGS, "SoTransform_pointAt(SoTransform self, SbVec3f frompoint, SbVec3f topoint)"},
	 { "SoTransform_getScaleSpaceMatrix", _wrap_SoTransform_getScaleSpaceMatrix, METH_VARARGS, "SoTransform_getScaleSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"},
	 { "SoTransform_getRotationSpaceMatrix", _wrap_SoTransform_getRotationSpaceMatrix, METH_VARARGS, "SoTransform_getRotationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"},
	 { "SoTransform_getTranslationSpaceMatrix", _wrap_SoTransform_getTranslationSpaceMatrix, METH_VARARGS, "SoTransform_getTranslationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"},
	 { "SoTransform_multLeft", _wrap_SoTransform_multLeft, METH_VARARGS, "SoTransform_multLeft(SoTransform self, SbMatrix mat)"},
	 { "SoTransform_multRight", _wrap_SoTransform_multRight, METH_VARARGS, "SoTransform_multRight(SoTransform self, SbMatrix mat)"},
	 { "SoTransform_combineLeft", _wrap_SoTransform_combineLeft, METH_VARARGS, "SoTransform_combineLeft(SoTransform self, SoTransformation nodeonright)"},
	 { "SoTransform_combineRight", _wrap_SoTransform_combineRight, METH_VARARGS, "SoTransform_combineRight(SoTransform self, SoTransformation nodeonleft)"},
	 { "SoTransform_setMatrix", _wrap_SoTransform_setMatrix, METH_VARARGS, "SoTransform_setMatrix(SoTransform self, SbMatrix mat)"},
	 { "SoTransform_recenter", _wrap_SoTransform_recenter, METH_VARARGS, "SoTransform_recenter(SoTransform self, SbVec3f newcenter)"},
	 { "SoTransform_doAction", _wrap_SoTransform_doAction, METH_VARARGS, "SoTransform_doAction(SoTransform self, SoAction action)"},
	 { "SoTransform_GLRender", _wrap_SoTransform_GLRender, METH_VARARGS, "SoTransform_GLRender(SoTransform self, SoGLRenderAction action)"},
	 { "SoTransform_callback", _wrap_SoTransform_callback, METH_VARARGS, "SoTransform_callback(SoTransform self, SoCallbackAction action)"},
	 { "SoTransform_getBoundingBox", _wrap_SoTransform_getBoundingBox, METH_VARARGS, "SoTransform_getBoundingBox(SoTransform self, SoGetBoundingBoxAction action)"},
	 { "SoTransform_getMatrix", _wrap_SoTransform_getMatrix, METH_VARARGS, "SoTransform_getMatrix(SoTransform self, SoGetMatrixAction action)"},
	 { "SoTransform_pick", _wrap_SoTransform_pick, METH_VARARGS, "SoTransform_pick(SoTransform self, SoPickAction action)"},
	 { "SoTransform_getPrimitiveCount", _wrap_SoTransform_getPrimitiveCount, METH_VARARGS, "SoTransform_getPrimitiveCount(SoTransform self, SoGetPrimitiveCountAction action)"},
	 { "SoTransform_swigregister", SoTransform_swigregister, METH_O, NULL},
	 { "SoTransform_swiginit", SoTransform_swiginit, METH_VARARGS, NULL},
	 { "SoTransformManip_getClassTypeId", _wrap_SoTransformManip_getClassTypeId, METH_NOARGS, "SoTransformManip_getClassTypeId() -> SoType"},
	 { "SoTransformManip_getTypeId", _wrap_SoTransformManip_getTypeId, METH_O, "SoTransformManip_getTypeId(SoTransformManip self) -> SoType"},
	 { "SoTransformManip_initClass", _wrap_SoTransformManip_initClass, METH_NOARGS, "SoTransformManip_initClass()"},
	 { "new_SoTransformManip", _wrap_new_SoTransformManip, METH_NOARGS, "new_SoTransformManip() -> SoTransformManip"},
	 { "SoTransformManip_getDragger", _wrap_SoTransformManip_getDragger, METH_O, "SoTransformManip_getDragger(SoTransformManip self) -> SoDragger"},
	 { "SoTransformManip_replaceNode", _wrap_SoTransformManip_replaceNode, METH_VARARGS, "SoTransformManip_replaceNode(SoTransformManip self, SoPath p) -> SbBool"},
	 { "SoTransformManip_replaceManip", _wrap_SoTransformManip_replaceManip, METH_VARARGS, "SoTransformManip_replaceManip(SoTransformManip self, SoPath p, SoTransform newone) -> SbBool"},
	 { "SoTransformManip_doAction", _wrap_SoTransformManip_doAction, METH_VARARGS, "SoTransformManip_doAction(SoTransformManip self, SoAction action)"},
	 { "SoTransformManip_callback", _wrap_SoTransformManip_callback, METH_VARARGS, "SoTransformManip_callback(SoTransformManip self, SoCallbackAction action)"},
	 { "SoTransformManip_GLRender", _wrap_SoTransformManip_GLRender, METH_VARARGS, "SoTransformManip_GLRender(SoTransformManip self, SoGLRenderAction action)"},
	 { "SoTransformManip_getBoundingBox", _wrap_SoTransformManip_getBoundingBox, METH_VARARGS, "SoTransformManip_getBoundingBox(SoTransformManip self, SoGetBoundingBoxAction action)"},
	 { "SoTransformManip_getMatrix", _wrap_SoTransformManip_getMatrix, METH_VARARGS, "SoTransformManip_getMatrix(SoTransformManip self, SoGetMatrixAction action)"},
	 { "SoTransformManip_handleEvent", _wrap_SoTransformManip_handleEvent, METH_VARARGS, "SoTransformManip_handleEvent(SoTransformManip self, SoHandleEventAction action)"},
	 { "SoTransformManip_pick", _wrap_SoTransformManip_pick, METH_VARARGS, "SoTransformManip_pick(SoTransformManip self, SoPickAction action)"},
	 { "SoTransformManip_search", _wrap_SoTransformManip_search, METH_VARARGS, "SoTransformManip_search(SoTransformManip self, SoSearchAction action)"},
	 { "SoTransformManip_getChildren", _wrap_SoTransformManip_getChildren, METH_O, "SoTransformManip_getChildren(SoTransformManip self) -> SoChildList"},
	 { "SoTransformManip_swigregister", SoTransformManip_swigregister, METH_O, NULL},
	 { "SoTransformManip_swiginit", SoTransformManip_swiginit, METH_VARARGS, NULL},
	 { "SoCenterballManip_getClassTypeId", _wrap_SoCenterballManip_getClassTypeId, METH_NOARGS, "SoCenterballManip_getClassTypeId() -> SoType"},
	 { "SoCenterballManip_getTypeId", _wrap_SoCenterballManip_getTypeId, METH_O, "SoCenterballManip_getTypeId(SoCenterballManip self) -> SoType"},
	 { "SoCenterballManip_initClass", _wrap_SoCenterballManip_initClass, METH_NOARGS, "SoCenterballManip_initClass()"},
	 { "new_SoCenterballManip", _wrap_new_SoCenterballManip, METH_NOARGS, "new_SoCenterballManip() -> SoCenterballManip"},
	 { "SoCenterballManip_swigregister", SoCenterballManip_swigregister, METH_O, NULL},
	 { "SoCenterballManip_swiginit", SoCenterballManip_swiginit, METH_VARARGS, NULL},
	 { "SoClipPlane_getClassTypeId", _wrap_SoClipPlane_getClassTypeId, METH_NOARGS, "SoClipPlane_getClassTypeId() -> SoType"},
	 { "SoClipPlane_getTypeId", _wrap_SoClipPlane_getTypeId, METH_O, "SoClipPlane_getTypeId(SoClipPlane self) -> SoType"},
	 { "SoClipPlane_initClass", _wrap_SoClipPlane_initClass, METH_NOARGS, "SoClipPlane_initClass()"},
	 { "new_SoClipPlane", _wrap_new_SoClipPlane, METH_NOARGS, "new_SoClipPlane() -> SoClipPlane"},
	 { "SoClipPlane_plane_set", _wrap_SoClipPlane_plane_set, METH_VARARGS, "SoClipPlane_plane_set(SoClipPlane self, SoSFPlane plane)"},
	 { "SoClipPlane_plane_get", _wrap_SoClipPlane_plane_get, METH_O, "SoClipPlane_plane_get(SoClipPlane self) -> SoSFPlane"},
	 { "SoClipPlane_on_set", _wrap_SoClipPlane_on_set, METH_VARARGS, "SoClipPlane_on_set(SoClipPlane self, SoSFBool on)"},
	 { "SoClipPlane_on_get", _wrap_SoClipPlane_on_get, METH_O, "SoClipPlane_on_get(SoClipPlane self) -> SoSFBool"},
	 { "SoClipPlane_doAction", _wrap_SoClipPlane_doAction, METH_VARARGS, "SoClipPlane_doAction(SoClipPlane self, SoAction action)"},
	 { "SoClipPlane_GLRender", _wrap_SoClipPlane_GLRender, METH_VARARGS, "SoClipPlane_GLRender(SoClipPlane self, SoGLRenderAction action)"},
	 { "SoClipPlane_callback", _wrap_SoClipPlane_callback, METH_VARARGS, "SoClipPlane_callback(SoClipPlane self, SoCallbackAction action)"},
	 { "SoClipPlane_pick", _wrap_SoClipPlane_pick, METH_VARARGS, "SoClipPlane_pick(SoClipPlane self, SoPickAction action)"},
	 { "SoClipPlane_swigregister", SoClipPlane_swigregister, METH_O, NULL},
	 { "SoClipPlane_swiginit", SoClipPlane_swiginit, METH_VARARGS, NULL},
	 { "SoClipPlaneManip_getClassTypeId", _wrap_SoClipPlaneManip_getClassTypeId, METH_NOARGS, "SoClipPlaneManip_getClassTypeId() -> SoType"},
	 { "SoClipPlaneManip_getTypeId", _wrap_SoClipPlaneManip_getTypeId, METH_O, "SoClipPlaneManip_getTypeId(SoClipPlaneManip self) -> SoType"},
	 { "SoClipPlaneManip_initClass", _wrap_SoClipPlaneManip_initClass, METH_NOARGS, "SoClipPlaneManip_initClass()"},
	 { "new_SoClipPlaneManip", _wrap_new_SoClipPlaneManip, METH_NOARGS, "new_SoClipPlaneManip() -> SoClipPlaneManip"},
	 { "SoClipPlaneManip_getDragger", _wrap_SoClipPlaneManip_getDragger, METH_O, "SoClipPlaneManip_getDragger(SoClipPlaneManip self) -> SoDragger"},
	 { "SoClipPlaneManip_setValue", _wrap_SoClipPlaneManip_setValue, METH_VARARGS, "SoClipPlaneManip_setValue(SoClipPlaneManip self, SbBox3f box, SbVec3f planenormal, float draggerscalefactor)"},
	 { "SoClipPlaneManip_replaceNode", _wrap_SoClipPlaneManip_replaceNode, METH_VARARGS, "SoClipPlaneManip_replaceNode(SoClipPlaneManip self, SoPath p) -> SbBool"},
	 { "SoClipPlaneManip_replaceManip", _wrap_SoClipPlaneManip_replaceManip, METH_VARARGS, "SoClipPlaneManip_replaceManip(SoClipPlaneManip self, SoPath p, SoClipPlane newone) -> SbBool"},
	 { "SoClipPlaneManip_doAction", _wrap_SoClipPlaneManip_doAction, METH_VARARGS, "SoClipPlaneManip_doAction(SoClipPlaneManip self, SoAction action)"},
	 { "SoClipPlaneManip_callback", _wrap_SoClipPlaneManip_callback, METH_VARARGS, "SoClipPlaneManip_callback(SoClipPlaneManip self, SoCallbackAction action)"},
	 { "SoClipPlaneManip_GLRender", _wrap_SoClipPlaneManip_GLRender, METH_VARARGS, "SoClipPlaneManip_GLRender(SoClipPlaneManip self, SoGLRenderAction action)"},
	 { "SoClipPlaneManip_getBoundingBox", _wrap_SoClipPlaneManip_getBoundingBox, METH_VARARGS, "SoClipPlaneManip_getBoundingBox(SoClipPlaneManip self, SoGetBoundingBoxAction action)"},
	 { "SoClipPlaneManip_getMatrix", _wrap_SoClipPlaneManip_getMatrix, METH_VARARGS, "SoClipPlaneManip_getMatrix(SoClipPlaneManip self, SoGetMatrixAction action)"},
	 { "SoClipPlaneManip_handleEvent", _wrap_SoClipPlaneManip_handleEvent, METH_VARARGS, "SoClipPlaneManip_handleEvent(SoClipPlaneManip self, SoHandleEventAction action)"},
	 { "SoClipPlaneManip_pick", _wrap_SoClipPlaneManip_pick, METH_VARARGS, "SoClipPlaneManip_pick(SoClipPlaneManip self, SoPickAction action)"},
	 { "SoClipPlaneManip_search", _wrap_SoClipPlaneManip_search, METH_VARARGS, "SoClipPlaneManip_search(SoClipPlaneManip self, SoSearchAction action)"},
	 { "SoClipPlaneManip_getChildren", _wrap_SoClipPlaneManip_getChildren, METH_O, "SoClipPlaneManip_getChildren(SoClipPlaneManip self) -> SoChildList"},
	 { "SoClipPlaneManip_draggerPosition_set", _wrap_SoClipPlaneManip_draggerPosition_set, METH_VARARGS, "SoClipPlaneManip_draggerPosition_set(SoClipPlaneManip self, SoSFVec3f draggerPosition)"},
	 { "SoClipPlaneManip_draggerPosition_get", _wrap_SoClipPlaneManip_draggerPosition_get, METH_O, "SoClipPlaneManip_draggerPosition_get(SoClipPlaneManip self) -> SoSFVec3f"},
	 { "SoClipPlaneManip_swigregister", SoClipPlaneManip_swigregister, METH_O, NULL},
	 { "SoClipPlaneManip_swiginit", SoClipPlaneManip_swiginit, METH_VARARGS, NULL},
	 { "SoLight_getClassTypeId", _wrap_SoLight_getClassTypeId, METH_NOARGS, "SoLight_getClassTypeId() -> SoType"},
	 { "SoLight_getTypeId", _wrap_SoLight_getTypeId, METH_O, "SoLight_getTypeId(SoLight self) -> SoType"},
	 { "SoLight_initClass", _wrap_SoLight_initClass, METH_NOARGS, "SoLight_initClass()"},
	 { "SoLight_on_set", _wrap_SoLight_on_set, METH_VARARGS, "SoLight_on_set(SoLight self, SoSFBool on)"},
	 { "SoLight_on_get", _wrap_SoLight_on_get, METH_O, "SoLight_on_get(SoLight self) -> SoSFBool"},
	 { "SoLight_intensity_set", _wrap_SoLight_intensity_set, METH_VARARGS, "SoLight_intensity_set(SoLight self, SoSFFloat intensity)"},
	 { "SoLight_intensity_get", _wrap_SoLight_intensity_get, METH_O, "SoLight_intensity_get(SoLight self) -> SoSFFloat"},
	 { "SoLight_color_set", _wrap_SoLight_color_set, METH_VARARGS, "SoLight_color_set(SoLight self, SoSFColor color)"},
	 { "SoLight_color_get", _wrap_SoLight_color_get, METH_O, "SoLight_color_get(SoLight self) -> SoSFColor"},
	 { "SoLight_callback", _wrap_SoLight_callback, METH_VARARGS, "SoLight_callback(SoLight self, SoCallbackAction action)"},
	 { "SoLight_swigregister", SoLight_swigregister, METH_O, NULL},
	 { "SoDirectionalLight_getClassTypeId", _wrap_SoDirectionalLight_getClassTypeId, METH_NOARGS, "SoDirectionalLight_getClassTypeId() -> SoType"},
	 { "SoDirectionalLight_getTypeId", _wrap_SoDirectionalLight_getTypeId, METH_O, "SoDirectionalLight_getTypeId(SoDirectionalLight self) -> SoType"},
	 { "SoDirectionalLight_initClass", _wrap_SoDirectionalLight_initClass, METH_NOARGS, "SoDirectionalLight_initClass()"},
	 { "new_SoDirectionalLight", _wrap_new_SoDirectionalLight, METH_NOARGS, "new_SoDirectionalLight() -> SoDirectionalLight"},
	 { "SoDirectionalLight_direction_set", _wrap_SoDirectionalLight_direction_set, METH_VARARGS, "SoDirectionalLight_direction_set(SoDirectionalLight self, SoSFVec3f direction)"},
	 { "SoDirectionalLight_direction_get", _wrap_SoDirectionalLight_direction_get, METH_O, "SoDirectionalLight_direction_get(SoDirectionalLight self) -> SoSFVec3f"},
	 { "SoDirectionalLight_GLRender", _wrap_SoDirectionalLight_GLRender, METH_VARARGS, "SoDirectionalLight_GLRender(SoDirectionalLight self, SoGLRenderAction action)"},
	 { "SoDirectionalLight_swigregister", SoDirectionalLight_swigregister, METH_O, NULL},
	 { "SoDirectionalLight_swiginit", SoDirectionalLight_swiginit, METH_VARARGS, NULL},
	 { "SoDirectionalLightManip_getClassTypeId", _wrap_SoDirectionalLightManip_getClassTypeId, METH_NOARGS, "SoDirectionalLightManip_getClassTypeId() -> SoType"},
	 { "SoDirectionalLightManip_getTypeId", _wrap_SoDirectionalLightManip_getTypeId, METH_O, "SoDirectionalLightManip_getTypeId(SoDirectionalLightManip self) -> SoType"},
	 { "SoDirectionalLightManip_initClass", _wrap_SoDirectionalLightManip_initClass, METH_NOARGS, "SoDirectionalLightManip_initClass()"},
	 { "new_SoDirectionalLightManip", _wrap_new_SoDirectionalLightManip, METH_NOARGS, "new_SoDirectionalLightManip() -> SoDirectionalLightManip"},
	 { "SoDirectionalLightManip_getDragger", _wrap_SoDirectionalLightManip_getDragger, METH_O, "SoDirectionalLightManip_getDragger(SoDirectionalLightManip self) -> SoDragger"},
	 { "SoDirectionalLightManip_replaceNode", _wrap_SoDirectionalLightManip_replaceNode, METH_VARARGS, "SoDirectionalLightManip_replaceNode(SoDirectionalLightManip self, SoPath path) -> SbBool"},
	 { "SoDirectionalLightManip_replaceManip", _wrap_SoDirectionalLightManip_replaceManip, METH_VARARGS, "SoDirectionalLightManip_replaceManip(SoDirectionalLightManip self, SoPath path, SoDirectionalLight newone) -> SbBool"},
	 { "SoDirectionalLightManip_doAction", _wrap_SoDirectionalLightManip_doAction, METH_VARARGS, "SoDirectionalLightManip_doAction(SoDirectionalLightManip self, SoAction action)"},
	 { "SoDirectionalLightManip_callback", _wrap_SoDirectionalLightManip_callback, METH_VARARGS, "SoDirectionalLightManip_callback(SoDirectionalLightManip self, SoCallbackAction action)"},
	 { "SoDirectionalLightManip_GLRender", _wrap_SoDirectionalLightManip_GLRender, METH_VARARGS, "SoDirectionalLightManip_GLRender(SoDirectionalLightManip self, SoGLRenderAction action)"},
	 { "SoDirectionalLightManip_getBoundingBox", _wrap_SoDirectionalLightManip_getBoundingBox, METH_VARARGS, "SoDirectionalLightManip_getBoundingBox(SoDirectionalLightManip self, SoGetBoundingBoxAction action)"},
	 { "SoDirectionalLightManip_getMatrix", _wrap_SoDirectionalLightManip_getMatrix, METH_VARARGS, "SoDirectionalLightManip_getMatrix(SoDirectionalLightManip self, SoGetMatrixAction action)"},
	 { "SoDirectionalLightManip_handleEvent", _wrap_SoDirectionalLightManip_handleEvent, METH_VARARGS, "SoDirectionalLightManip_handleEvent(SoDirectionalLightManip self, SoHandleEventAction action)"},
	 { "SoDirectionalLightManip_pick", _wrap_SoDirectionalLightManip_pick, METH_VARARGS, "SoDirectionalLightManip_pick(SoDirectionalLightManip self, SoPickAction action)"},
	 { "SoDirectionalLightManip_search", _wrap_SoDirectionalLightManip_search, METH_VARARGS, "SoDirectionalLightManip_search(SoDirectionalLightManip self, SoSearchAction action)"},
	 { "SoDirectionalLightManip_getChildren", _wrap_SoDirectionalLightManip_getChildren, METH_O, "SoDirectionalLightManip_getChildren(SoDirectionalLightManip self) -> SoChildList"},
	 { "SoDirectionalLightManip_swigregister", SoDirectionalLightManip_swigregister, METH_O, NULL},
	 { "SoDirectionalLightManip_swiginit", SoDirectionalLightManip_swiginit, METH_VARARGS, NULL},
	 { "SoHandleBoxManip_getClassTypeId", _wrap_SoHandleBoxManip_getClassTypeId, METH_NOARGS, "SoHandleBoxManip_getClassTypeId() -> SoType"},
	 { "SoHandleBoxManip_getTypeId", _wrap_SoHandleBoxManip_getTypeId, METH_O, "SoHandleBoxManip_getTypeId(SoHandleBoxManip self) -> SoType"},
	 { "SoHandleBoxManip_initClass", _wrap_SoHandleBoxManip_initClass, METH_NOARGS, "SoHandleBoxManip_initClass()"},
	 { "new_SoHandleBoxManip", _wrap_new_SoHandleBoxManip, METH_NOARGS, "new_SoHandleBoxManip() -> SoHandleBoxManip"},
	 { "SoHandleBoxManip_swigregister", SoHandleBoxManip_swigregister, METH_O, NULL},
	 { "SoHandleBoxManip_swiginit", SoHandleBoxManip_swiginit, METH_VARARGS, NULL},
	 { "SoJackManip_getClassTypeId", _wrap_SoJackManip_getClassTypeId, METH_NOARGS, "SoJackManip_getClassTypeId() -> SoType"},
	 { "SoJackManip_getTypeId", _wrap_SoJackManip_getTypeId, METH_O, "SoJackManip_getTypeId(SoJackManip self) -> SoType"},
	 { "SoJackManip_initClass", _wrap_SoJackManip_initClass, METH_NOARGS, "SoJackManip_initClass()"},
	 { "new_SoJackManip", _wrap_new_SoJackManip, METH_NOARGS, "new_SoJackManip() -> SoJackManip"},
	 { "SoJackManip_swigregister", SoJackManip_swigregister, METH_O, NULL},
	 { "SoJackManip_swiginit", SoJackManip_swiginit, METH_VARARGS, NULL},
	 { "SoPointLight_getClassTypeId", _wrap_SoPointLight_getClassTypeId, METH_NOARGS, "SoPointLight_getClassTypeId() -> SoType"},
	 { "SoPointLight_getTypeId", _wrap_SoPointLight_getTypeId, METH_O, "SoPointLight_getTypeId(SoPointLight self) -> SoType"},
	 { "SoPointLight_initClass", _wrap_SoPointLight_initClass, METH_NOARGS, "SoPointLight_initClass()"},
	 { "new_SoPointLight", _wrap_new_SoPointLight, METH_NOARGS, "new_SoPointLight() -> SoPointLight"},
	 { "SoPointLight_location_set", _wrap_SoPointLight_location_set, METH_VARARGS, "SoPointLight_location_set(SoPointLight self, SoSFVec3f location)"},
	 { "SoPointLight_location_get", _wrap_SoPointLight_location_get, METH_O, "SoPointLight_location_get(SoPointLight self) -> SoSFVec3f"},
	 { "SoPointLight_GLRender", _wrap_SoPointLight_GLRender, METH_VARARGS, "SoPointLight_GLRender(SoPointLight self, SoGLRenderAction action)"},
	 { "SoPointLight_swigregister", SoPointLight_swigregister, METH_O, NULL},
	 { "SoPointLight_swiginit", SoPointLight_swiginit, METH_VARARGS, NULL},
	 { "SoPointLightManip_getClassTypeId", _wrap_SoPointLightManip_getClassTypeId, METH_NOARGS, "SoPointLightManip_getClassTypeId() -> SoType"},
	 { "SoPointLightManip_getTypeId", _wrap_SoPointLightManip_getTypeId, METH_O, "SoPointLightManip_getTypeId(SoPointLightManip self) -> SoType"},
	 { "SoPointLightManip_initClass", _wrap_SoPointLightManip_initClass, METH_NOARGS, "SoPointLightManip_initClass()"},
	 { "new_SoPointLightManip", _wrap_new_SoPointLightManip, METH_NOARGS, "new_SoPointLightManip() -> SoPointLightManip"},
	 { "SoPointLightManip_getDragger", _wrap_SoPointLightManip_getDragger, METH_O, "SoPointLightManip_getDragger(SoPointLightManip self) -> SoDragger"},
	 { "SoPointLightManip_replaceNode", _wrap_SoPointLightManip_replaceNode, METH_VARARGS, "SoPointLightManip_replaceNode(SoPointLightManip self, SoPath path) -> SbBool"},
	 { "SoPointLightManip_replaceManip", _wrap_SoPointLightManip_replaceManip, METH_VARARGS, "SoPointLightManip_replaceManip(SoPointLightManip self, SoPath path, SoPointLight newone) -> SbBool"},
	 { "SoPointLightManip_doAction", _wrap_SoPointLightManip_doAction, METH_VARARGS, "SoPointLightManip_doAction(SoPointLightManip self, SoAction action)"},
	 { "SoPointLightManip_callback", _wrap_SoPointLightManip_callback, METH_VARARGS, "SoPointLightManip_callback(SoPointLightManip self, SoCallbackAction action)"},
	 { "SoPointLightManip_GLRender", _wrap_SoPointLightManip_GLRender, METH_VARARGS, "SoPointLightManip_GLRender(SoPointLightManip self, SoGLRenderAction action)"},
	 { "SoPointLightManip_getBoundingBox", _wrap_SoPointLightManip_getBoundingBox, METH_VARARGS, "SoPointLightManip_getBoundingBox(SoPointLightManip self, SoGetBoundingBoxAction action)"},
	 { "SoPointLightManip_getMatrix", _wrap_SoPointLightManip_getMatrix, METH_VARARGS, "SoPointLightManip_getMatrix(SoPointLightManip self, SoGetMatrixAction action)"},
	 { "SoPointLightManip_handleEvent", _wrap_SoPointLightManip_handleEvent, METH_VARARGS, "SoPointLightManip_handleEvent(SoPointLightManip self, SoHandleEventAction action)"},
	 { "SoPointLightManip_pick", _wrap_SoPointLightManip_pick, METH_VARARGS, "SoPointLightManip_pick(SoPointLightManip self, SoPickAction action)"},
	 { "SoPointLightManip_search", _wrap_SoPointLightManip_search, METH_VARARGS, "SoPointLightManip_search(SoPointLightManip self, SoSearchAction action)"},
	 { "SoPointLightManip_getChildren", _wrap_SoPointLightManip_getChildren, METH_O, "SoPointLightManip_getChildren(SoPointLightManip self) -> SoChildList"},
	 { "SoPointLightManip_swigregister", SoPointLightManip_swigregister, METH_O, NULL},
	 { "SoPointLightManip_swiginit", SoPointLightManip_swiginit, METH_VARARGS, NULL},
	 { "SoSpotLight_getClassTypeId", _wrap_SoSpotLight_getClassTypeId, METH_NOARGS, "SoSpotLight_getClassTypeId() -> SoType"},
	 { "SoSpotLight_getTypeId", _wrap_SoSpotLight_getTypeId, METH_O, "SoSpotLight_getTypeId(SoSpotLight self) -> SoType"},
	 { "SoSpotLight_initClass", _wrap_SoSpotLight_initClass, METH_NOARGS, "SoSpotLight_initClass()"},
	 { "new_SoSpotLight", _wrap_new_SoSpotLight, METH_NOARGS, "new_SoSpotLight() -> SoSpotLight"},
	 { "SoSpotLight_location_set", _wrap_SoSpotLight_location_set, METH_VARARGS, "SoSpotLight_location_set(SoSpotLight self, SoSFVec3f location)"},
	 { "SoSpotLight_location_get", _wrap_SoSpotLight_location_get, METH_O, "SoSpotLight_location_get(SoSpotLight self) -> SoSFVec3f"},
	 { "SoSpotLight_direction_set", _wrap_SoSpotLight_direction_set, METH_VARARGS, "SoSpotLight_direction_set(SoSpotLight self, SoSFVec3f direction)"},
	 { "SoSpotLight_direction_get", _wrap_SoSpotLight_direction_get, METH_O, "SoSpotLight_direction_get(SoSpotLight self) -> SoSFVec3f"},
	 { "SoSpotLight_dropOffRate_set", _wrap_SoSpotLight_dropOffRate_set, METH_VARARGS, "SoSpotLight_dropOffRate_set(SoSpotLight self, SoSFFloat dropOffRate)"},
	 { "SoSpotLight_dropOffRate_get", _wrap_SoSpotLight_dropOffRate_get, METH_O, "SoSpotLight_dropOffRate_get(SoSpotLight self) -> SoSFFloat"},
	 { "SoSpotLight_cutOffAngle_set", _wrap_SoSpotLight_cutOffAngle_set, METH_VARARGS, "SoSpotLight_cutOffAngle_set(SoSpotLight self, SoSFFloat cutOffAngle)"},
	 { "SoSpotLight_cutOffAngle_get", _wrap_SoSpotLight_cutOffAngle_get, METH_O, "SoSpotLight_cutOffAngle_get(SoSpotLight self) -> SoSFFloat"},
	 { "SoSpotLight_GLRender", _wrap_SoSpotLight_GLRender, METH_VARARGS, "SoSpotLight_GLRender(SoSpotLight self, SoGLRenderAction action)"},
	 { "SoSpotLight_swigregister", SoSpotLight_swigregister, METH_O, NULL},
	 { "SoSpotLight_swiginit", SoSpotLight_swiginit, METH_VARARGS, NULL},
	 { "SoSpotLightManip_getClassTypeId", _wrap_SoSpotLightManip_getClassTypeId, METH_NOARGS, "SoSpotLightManip_getClassTypeId() -> SoType"},
	 { "SoSpotLightManip_getTypeId", _wrap_SoSpotLightManip_getTypeId, METH_O, "SoSpotLightManip_getTypeId(SoSpotLightManip self) -> SoType"},
	 { "SoSpotLightManip_initClass", _wrap_SoSpotLightManip_initClass, METH_NOARGS, "SoSpotLightManip_initClass()"},
	 { "new_SoSpotLightManip", _wrap_new_SoSpotLightManip, METH_NOARGS, "new_SoSpotLightManip() -> SoSpotLightManip"},
	 { "SoSpotLightManip_getDragger", _wrap_SoSpotLightManip_getDragger, METH_O, "SoSpotLightManip_getDragger(SoSpotLightManip self) -> SoDragger"},
	 { "SoSpotLightManip_replaceNode", _wrap_SoSpotLightManip_replaceNode, METH_VARARGS, "SoSpotLightManip_replaceNode(SoSpotLightManip self, SoPath p) -> SbBool"},
	 { "SoSpotLightManip_replaceManip", _wrap_SoSpotLightManip_replaceManip, METH_VARARGS, "SoSpotLightManip_replaceManip(SoSpotLightManip self, SoPath p, SoSpotLight newone) -> SbBool"},
	 { "SoSpotLightManip_doAction", _wrap_SoSpotLightManip_doAction, METH_VARARGS, "SoSpotLightManip_doAction(SoSpotLightManip self, SoAction action)"},
	 { "SoSpotLightManip_callback", _wrap_SoSpotLightManip_callback, METH_VARARGS, "SoSpotLightManip_callback(SoSpotLightManip self, SoCallbackAction action)"},
	 { "SoSpotLightManip_GLRender", _wrap_SoSpotLightManip_GLRender, METH_VARARGS, "SoSpotLightManip_GLRender(SoSpotLightManip self, SoGLRenderAction action)"},
	 { "SoSpotLightManip_getBoundingBox", _wrap_SoSpotLightManip_getBoundingBox, METH_VARARGS, "SoSpotLightManip_getBoundingBox(SoSpotLightManip self, SoGetBoundingBoxAction action)"},
	 { "SoSpotLightManip_getMatrix", _wrap_SoSpotLightManip_getMatrix, METH_VARARGS, "SoSpotLightManip_getMatrix(SoSpotLightManip self, SoGetMatrixAction action)"},
	 { "SoSpotLightManip_handleEvent", _wrap_SoSpotLightManip_handleEvent, METH_VARARGS, "SoSpotLightManip_handleEvent(SoSpotLightManip self, SoHandleEventAction action)"},
	 { "SoSpotLightManip_pick", _wrap_SoSpotLightManip_pick, METH_VARARGS, "SoSpotLightManip_pick(SoSpotLightManip self, SoPickAction action)"},
	 { "SoSpotLightManip_search", _wrap_SoSpotLightManip_search, METH_VARARGS, "SoSpotLightManip_search(SoSpotLightManip self, SoSearchAction action)"},
	 { "SoSpotLightManip_getChildren", _wrap_SoSpotLightManip_getChildren, METH_O, "SoSpotLightManip_getChildren(SoSpotLightManip self) -> SoChildList"},
	 { "SoSpotLightManip_swigregister", SoSpotLightManip_swigregister, METH_O, NULL},
	 { "SoSpotLightManip_swiginit", SoSpotLightManip_swiginit, METH_VARARGS, NULL},
	 { "SoTabBoxManip_getClassTypeId", _wrap_SoTabBoxManip_getClassTypeId, METH_NOARGS, "SoTabBoxManip_getClassTypeId() -> SoType"},
	 { "SoTabBoxManip_getTypeId", _wrap_SoTabBoxManip_getTypeId, METH_O, "SoTabBoxManip_getTypeId(SoTabBoxManip self) -> SoType"},
	 { "SoTabBoxManip_initClass", _wrap_SoTabBoxManip_initClass, METH_NOARGS, "SoTabBoxManip_initClass()"},
	 { "new_SoTabBoxManip", _wrap_new_SoTabBoxManip, METH_NOARGS, "new_SoTabBoxManip() -> SoTabBoxManip"},
	 { "SoTabBoxManip_swigregister", SoTabBoxManip_swigregister, METH_O, NULL},
	 { "SoTabBoxManip_swiginit", SoTabBoxManip_swiginit, METH_VARARGS, NULL},
	 { "SoTrackballManip_getClassTypeId", _wrap_SoTrackballManip_getClassTypeId, METH_NOARGS, "SoTrackballManip_getClassTypeId() -> SoType"},
	 { "SoTrackballManip_getTypeId", _wrap_SoTrackballManip_getTypeId, METH_O, "SoTrackballManip_getTypeId(SoTrackballManip self) -> SoType"},
	 { "SoTrackballManip_initClass", _wrap_SoTrackballManip_initClass, METH_NOARGS, "SoTrackballManip_initClass()"},
	 { "new_SoTrackballManip", _wrap_new_SoTrackballManip, METH_NOARGS, "new_SoTrackballManip() -> SoTrackballManip"},
	 { "SoTrackballManip_swigregister", SoTrackballManip_swigregister, METH_O, NULL},
	 { "SoTrackballManip_swiginit", SoTrackballManip_swiginit, METH_VARARGS, NULL},
	 { "SoTransformBoxManip_getClassTypeId", _wrap_SoTransformBoxManip_getClassTypeId, METH_NOARGS, "SoTransformBoxManip_getClassTypeId() -> SoType"},
	 { "SoTransformBoxManip_getTypeId", _wrap_SoTransformBoxManip_getTypeId, METH_O, "SoTransformBoxManip_getTypeId(SoTransformBoxManip self) -> SoType"},
	 { "SoTransformBoxManip_initClass", _wrap_SoTransformBoxManip_initClass, METH_NOARGS, "SoTransformBoxManip_initClass()"},
	 { "new_SoTransformBoxManip", _wrap_new_SoTransformBoxManip, METH_NOARGS, "new_SoTransformBoxManip() -> SoTransformBoxManip"},
	 { "SoTransformBoxManip_swigregister", SoTransformBoxManip_swigregister, METH_O, NULL},
	 { "SoTransformBoxManip_swiginit", SoTransformBoxManip_swiginit, METH_VARARGS, NULL},
	 { "SoTransformerManip_getClassTypeId", _wrap_SoTransformerManip_getClassTypeId, METH_NOARGS, "SoTransformerManip_getClassTypeId() -> SoType"},
	 { "SoTransformerManip_getTypeId", _wrap_SoTransformerManip_getTypeId, METH_O, "SoTransformerManip_getTypeId(SoTransformerManip self) -> SoType"},
	 { "SoTransformerManip_initClass", _wrap_SoTransformerManip_initClass, METH_NOARGS, "SoTransformerManip_initClass()"},
	 { "new_SoTransformerManip", _wrap_new_SoTransformerManip, METH_NOARGS, "new_SoTransformerManip() -> SoTransformerManip"},
	 { "SoTransformerManip_isLocateHighlighting", _wrap_SoTransformerManip_isLocateHighlighting, METH_O, "SoTransformerManip_isLocateHighlighting(SoTransformerManip self) -> SbBool"},
	 { "SoTransformerManip_setLocateHighlighting", _wrap_SoTransformerManip_setLocateHighlighting, METH_VARARGS, "SoTransformerManip_setLocateHighlighting(SoTransformerManip self, SbBool onoff)"},
	 { "SoTransformerManip_unsquishKnobs", _wrap_SoTransformerManip_unsquishKnobs, METH_O, "SoTransformerManip_unsquishKnobs(SoTransformerManip self)"},
	 { "SoTransformerManip_swigregister", SoTransformerManip_swigregister, METH_O, NULL},
	 { "SoTransformerManip_swiginit", SoTransformerManip_swiginit, METH_VARARGS, NULL},
	 { "SoAudioDevice_instance", _wrap_SoAudioDevice_instance, METH_NOARGS, "SoAudioDevice_instance() -> SoAudioDevice"},
	 { "SoAudioDevice_init", _wrap_SoAudioDevice_init, METH_VARARGS, "SoAudioDevice_init(SoAudioDevice self, SbString devicetype, SbString devicename) -> SbBool"},
	 { "SoAudioDevice_enable", _wrap_SoAudioDevice_enable, METH_O, "SoAudioDevice_enable(SoAudioDevice self) -> SbBool"},
	 { "SoAudioDevice_disable", _wrap_SoAudioDevice_disable, METH_O, "SoAudioDevice_disable(SoAudioDevice self)"},
	 { "SoAudioDevice_isEnabled", _wrap_SoAudioDevice_isEnabled, METH_O, "SoAudioDevice_isEnabled(SoAudioDevice self) -> SbBool"},
	 { "SoAudioDevice_haveSound", _wrap_SoAudioDevice_haveSound, METH_O, "SoAudioDevice_haveSound(SoAudioDevice self) -> SbBool"},
	 { "SoAudioDevice_setGain", _wrap_SoAudioDevice_setGain, METH_VARARGS, "SoAudioDevice_setGain(SoAudioDevice self, float gain)"},
	 { "SoAudioDevice_mute", _wrap_SoAudioDevice_mute, METH_VARARGS, "SoAudioDevice_mute(SoAudioDevice self, SbBool mute=1)"},
	 { "SoAudioDevice_swigregister", SoAudioDevice_swigregister, METH_O, NULL},
	 { "new_SoByteStream", _wrap_new_SoByteStream, METH_NOARGS, "new_SoByteStream() -> SoByteStream"},
	 { "delete_SoByteStream", _wrap_delete_SoByteStream, METH_O, "delete_SoByteStream(SoByteStream self)"},
	 { "SoByteStream_convert", _wrap_SoByteStream_convert, METH_VARARGS, "\n"
		"SoByteStream_convert(SoByteStream self, SoNode node, SbBool binary=1)\n"
		"SoByteStream_convert(SoByteStream self, SoPath path, SbBool binary=1)\n"
		"SoByteStream_convert(SoByteStream self, SoPathList pl, SbBool binary=1)\n"
		""},
	 { "SoByteStream_getData", _wrap_SoByteStream_getData, METH_O, "SoByteStream_getData(SoByteStream self) -> void *"},
	 { "SoByteStream_getNumBytes", _wrap_SoByteStream_getNumBytes, METH_O, "SoByteStream_getNumBytes(SoByteStream self) -> uint32_t"},
	 { "SoByteStream_unconvert", _wrap_SoByteStream_unconvert, METH_VARARGS, "\n"
		"SoByteStream_unconvert(SoByteStream stream) -> SoPathList\n"
		"SoByteStream_unconvert(void * data, uint32_t bytesinstream) -> SoPathList\n"
		""},
	 { "SoByteStream_copy", _wrap_SoByteStream_copy, METH_VARARGS, "SoByteStream_copy(SoByteStream self, void * d, size_t len)"},
	 { "SoByteStream_isRawData", _wrap_SoByteStream_isRawData, METH_O, "SoByteStream_isRawData(SoByteStream self) -> SbBool"},
	 { "SoByteStream_swigregister", SoByteStream_swigregister, METH_O, NULL},
	 { "SoByteStream_swiginit", SoByteStream_swiginit, METH_VARARGS, NULL},
	 { "SoContextHandler_destructingContext", _wrap_SoContextHandler_destructingContext, METH_O, "SoContextHandler_destructingContext(uint32_t contextid)"},
	 { "SoContextHandler_addContextDestructionCallback", _wrap_SoContextHandler_addContextDestructionCallback, METH_VARARGS, "SoContextHandler_addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"},
	 { "SoContextHandler_removeContextDestructionCallback", _wrap_SoContextHandler_removeContextDestructionCallback, METH_VARARGS, "SoContextHandler_removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"},
	 { "new_SoContextHandler", _wrap_new_SoContextHandler, METH_NOARGS, "new_SoContextHandler() -> SoContextHandler"},
	 { "delete_SoContextHandler", _wrap_delete_SoContextHandler, METH_O, "delete_SoContextHandler(SoContextHandler self)"},
	 { "SoContextHandler_swigregister", SoContextHandler_swigregister, METH_O, NULL},
	 { "SoContextHandler_swiginit", SoContextHandler_swiginit, METH_VARARGS, NULL},
	 { "new_SoGLImage", _wrap_new_SoGLImage, METH_NOARGS, "new_SoGLImage() -> SoGLImage"},
	 { "SoGLImage_unref", _wrap_SoGLImage_unref, METH_VARARGS, "SoGLImage_unref(SoGLImage self, SoState state=None)"},
	 { "SoGLImage_getClassTypeId", _wrap_SoGLImage_getClassTypeId, METH_NOARGS, "SoGLImage_getClassTypeId() -> SoType"},
	 { "SoGLImage_getTypeId", _wrap_SoGLImage_getTypeId, METH_O, "SoGLImage_getTypeId(SoGLImage self) -> SoType"},
	 { "SoGLImage_isOfType", _wrap_SoGLImage_isOfType, METH_VARARGS, "SoGLImage_isOfType(SoGLImage self, SoType type) -> SbBool"},
	 { "SoGLImage_setGLDisplayList", _wrap_SoGLImage_setGLDisplayList, METH_VARARGS, "SoGLImage_setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"},
	 { "SoGLImage_setPBuffer", _wrap_SoGLImage_setPBuffer, METH_VARARGS, "SoGLImage_setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"},
	 { "SoGLImage_setData", _wrap_SoGLImage_setData, METH_VARARGS, "\n"
		"SoGLImage_setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		"SoGLImage_setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, SoGLImage::Wrap const wrapr=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		"SoGLImage_setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		"SoGLImage_setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		""},
	 { "SoGLImage_setFlags", _wrap_SoGLImage_setFlags, METH_VARARGS, "SoGLImage_setFlags(SoGLImage self, uint32_t const flags)"},
	 { "SoGLImage_getFlags", _wrap_SoGLImage_getFlags, METH_O, "SoGLImage_getFlags(SoGLImage self) -> uint32_t"},
	 { "SoGLImage_getImage", _wrap_SoGLImage_getImage, METH_O, "SoGLImage_getImage(SoGLImage self) -> SbImage"},
	 { "SoGLImage_getGLDisplayList", _wrap_SoGLImage_getGLDisplayList, METH_VARARGS, "SoGLImage_getGLDisplayList(SoGLImage self, SoState state) -> SoGLDisplayList"},
	 { "SoGLImage_hasTransparency", _wrap_SoGLImage_hasTransparency, METH_O, "SoGLImage_hasTransparency(SoGLImage self) -> SbBool"},
	 { "SoGLImage_useAlphaTest", _wrap_SoGLImage_useAlphaTest, METH_O, "SoGLImage_useAlphaTest(SoGLImage self) -> SbBool"},
	 { "SoGLImage_getWrapS", _wrap_SoGLImage_getWrapS, METH_O, "SoGLImage_getWrapS(SoGLImage self) -> SoGLImage::Wrap"},
	 { "SoGLImage_getWrapT", _wrap_SoGLImage_getWrapT, METH_O, "SoGLImage_getWrapT(SoGLImage self) -> SoGLImage::Wrap"},
	 { "SoGLImage_getWrapR", _wrap_SoGLImage_getWrapR, METH_O, "SoGLImage_getWrapR(SoGLImage self) -> SoGLImage::Wrap"},
	 { "SoGLImage_getQuality", _wrap_SoGLImage_getQuality, METH_O, "SoGLImage_getQuality(SoGLImage self) -> float"},
	 { "SoGLImage_getGLImageId", _wrap_SoGLImage_getGLImageId, METH_O, "SoGLImage_getGLImageId(SoGLImage self) -> uint32_t"},
	 { "SoGLImage_beginFrame", _wrap_SoGLImage_beginFrame, METH_O, "SoGLImage_beginFrame(SoState state)"},
	 { "SoGLImage_tagImage", _wrap_SoGLImage_tagImage, METH_VARARGS, "SoGLImage_tagImage(SoState state, SoGLImage image)"},
	 { "SoGLImage_endFrame", _wrap_SoGLImage_endFrame, METH_O, "SoGLImage_endFrame(SoState state)"},
	 { "SoGLImage_setDisplayListMaxAge", _wrap_SoGLImage_setDisplayListMaxAge, METH_O, "SoGLImage_setDisplayListMaxAge(uint32_t const maxage)"},
	 { "SoGLImage_freeAllImages", _wrap_SoGLImage_freeAllImages, METH_VARARGS, "SoGLImage_freeAllImages(SoState state=None)"},
	 { "SoGLImage_setEndFrameCallback", _wrap_SoGLImage_setEndFrameCallback, METH_VARARGS, "SoGLImage_setEndFrameCallback(SoGLImage self, void (*)(void *) cb, void * closure)"},
	 { "SoGLImage_getNumFramesSinceUsed", _wrap_SoGLImage_getNumFramesSinceUsed, METH_O, "SoGLImage_getNumFramesSinceUsed(SoGLImage self) -> int"},
	 { "SoGLImage_initClass", _wrap_SoGLImage_initClass, METH_NOARGS, "SoGLImage_initClass()"},
	 { "SoGLImage_setResizeCallback", _wrap_SoGLImage_setResizeCallback, METH_VARARGS, "SoGLImage_setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"},
	 { "SoGLImage_swigregister", SoGLImage_swigregister, METH_O, NULL},
	 { "SoGLImage_swiginit", SoGLImage_swiginit, METH_VARARGS, NULL},
	 { "new_SoGLBigImage", _wrap_new_SoGLBigImage, METH_NOARGS, "new_SoGLBigImage() -> SoGLBigImage"},
	 { "SoGLBigImage_unref", _wrap_SoGLBigImage_unref, METH_VARARGS, "SoGLBigImage_unref(SoGLBigImage self, SoState state=None)"},
	 { "SoGLBigImage_getClassTypeId", _wrap_SoGLBigImage_getClassTypeId, METH_NOARGS, "SoGLBigImage_getClassTypeId() -> SoType"},
	 { "SoGLBigImage_getTypeId", _wrap_SoGLBigImage_getTypeId, METH_O, "SoGLBigImage_getTypeId(SoGLBigImage self) -> SoType"},
	 { "SoGLBigImage_setData", _wrap_SoGLBigImage_setData, METH_VARARGS, "\n"
		"SoGLBigImage_setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		"SoGLBigImage_setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)\n"
		""},
	 { "SoGLBigImage_initSubImages", _wrap_SoGLBigImage_initSubImages, METH_VARARGS, "SoGLBigImage_initSubImages(SoGLBigImage self, SbVec2s subimagesize) -> int"},
	 { "SoGLBigImage_handleSubImage", _wrap_SoGLBigImage_handleSubImage, METH_VARARGS, "SoGLBigImage_handleSubImage(SoGLBigImage self, int const idx, SbVec2f start, SbVec2f end, SbVec2f tcmul)"},
	 { "SoGLBigImage_applySubImage", _wrap_SoGLBigImage_applySubImage, METH_VARARGS, "SoGLBigImage_applySubImage(SoGLBigImage self, SoState state, int const idx, float const quality, SbVec2s projsize)"},
	 { "SoGLBigImage_exceededChangeLimit", _wrap_SoGLBigImage_exceededChangeLimit, METH_O, "SoGLBigImage_exceededChangeLimit(SoGLBigImage self) -> SbBool"},
	 { "SoGLBigImage_setChangeLimit", _wrap_SoGLBigImage_setChangeLimit, METH_O, "SoGLBigImage_setChangeLimit(int const limit) -> int"},
	 { "SoGLBigImage_getGLDisplayList", _wrap_SoGLBigImage_getGLDisplayList, METH_VARARGS, "SoGLBigImage_getGLDisplayList(SoGLBigImage self, SoState state) -> SoGLDisplayList"},
	 { "SoGLBigImage_initClass", _wrap_SoGLBigImage_initClass, METH_NOARGS, "SoGLBigImage_initClass()"},
	 { "SoGLBigImage_swigregister", SoGLBigImage_swigregister, METH_O, NULL},
	 { "SoGLBigImage_swiginit", SoGLBigImage_swiginit, METH_VARARGS, NULL},
	 { "SoGlyph_unref", _wrap_SoGlyph_unref, METH_O, "SoGlyph_unref(SoGlyph self)"},
	 { "SoGlyph_getCoords", _wrap_SoGlyph_getCoords, METH_O, "SoGlyph_getCoords(SoGlyph self) -> SbVec2f"},
	 { "SoGlyph_getFaceIndices", _wrap_SoGlyph_getFaceIndices, METH_O, "SoGlyph_getFaceIndices(SoGlyph self) -> int const *"},
	 { "SoGlyph_getEdgeIndices", _wrap_SoGlyph_getEdgeIndices, METH_O, "SoGlyph_getEdgeIndices(SoGlyph self) -> int const *"},
	 { "SoGlyph_getNextCWEdge", _wrap_SoGlyph_getNextCWEdge, METH_VARARGS, "SoGlyph_getNextCWEdge(SoGlyph self, int const edgeidx) -> int const *"},
	 { "SoGlyph_getNextCCWEdge", _wrap_SoGlyph_getNextCCWEdge, METH_VARARGS, "SoGlyph_getNextCCWEdge(SoGlyph self, int const edgeidx) -> int const *"},
	 { "SoGlyph_getWidth", _wrap_SoGlyph_getWidth, METH_O, "SoGlyph_getWidth(SoGlyph self) -> float"},
	 { "SoGlyph_getBoundingBox", _wrap_SoGlyph_getBoundingBox, METH_O, "SoGlyph_getBoundingBox(SoGlyph self) -> SbBox2f"},
	 { "SoGlyph_getGlyph", _wrap_SoGlyph_getGlyph, METH_VARARGS, "\n"
		"SoGlyph_getGlyph(char const character, SbName font) -> SoGlyph\n"
		"SoGlyph_getGlyph(SoState state, unsigned int const character, SbVec2s size, float const angle) -> SoGlyph\n"
		""},
	 { "SoGlyph_getAdvance", _wrap_SoGlyph_getAdvance, METH_O, "SoGlyph_getAdvance(SoGlyph self) -> SbVec2s"},
	 { "SoGlyph_getKerning", _wrap_SoGlyph_getKerning, METH_VARARGS, "SoGlyph_getKerning(SoGlyph self, SoGlyph rightglyph) -> SbVec2s"},
	 { "SoGlyph_getBitmap", _wrap_SoGlyph_getBitmap, METH_VARARGS, "SoGlyph_getBitmap(SoGlyph self, SbVec2s size, SbVec2s pos, SbBool const antialiased) -> unsigned char *"},
	 { "SoGlyph_swigregister", SoGlyph_swigregister, METH_O, NULL},
	 { "new_SbDPMatrix", _wrap_new_SbDPMatrix, METH_VARARGS, "\n"
		"SbDPMatrix()\n"
		"SbDPMatrix(double const a11, double const a12, double const a13, double const a14, double const a21, double const a22, double const a23, double const a24, double const a31, double const a32, double const a33, double const a34, double const a41, double const a42, double const a43, double const a44)\n"
		"SbDPMatrix(SbDPMat const & matrix)\n"
		"SbDPMatrix(SbDPMat const * matrix)\n"
		"new_SbDPMatrix() -> SbDPMatrix\n"
		""},
	 { "delete_SbDPMatrix", _wrap_delete_SbDPMatrix, METH_O, "delete_SbDPMatrix(SbDPMatrix self)"},
	 { "SbDPMatrix_setValue", _wrap_SbDPMatrix_setValue, METH_VARARGS, "\n"
		"SbDPMatrix_setValue(SbDPMatrix self, SbDPMat const & m)\n"
		"SbDPMatrix_setValue(SbDPMatrix self, SbMatrix m)\n"
		"SbDPMatrix_setValue(SbDPMatrix self, double const * pMat)\n"
		""},
	 { "SbDPMatrix_makeIdentity", _wrap_SbDPMatrix_makeIdentity, METH_O, "SbDPMatrix_makeIdentity(SbDPMatrix self)"},
	 { "SbDPMatrix_setRotate", _wrap_SbDPMatrix_setRotate, METH_VARARGS, "SbDPMatrix_setRotate(SbDPMatrix self, SbDPRotation q)"},
	 { "SbDPMatrix_inverse", _wrap_SbDPMatrix_inverse, METH_O, "SbDPMatrix_inverse(SbDPMatrix self) -> SbDPMatrix"},
	 { "SbDPMatrix_det3", _wrap_SbDPMatrix_det3, METH_VARARGS, "\n"
		"SbDPMatrix_det3(SbDPMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> double\n"
		"SbDPMatrix_det3(SbDPMatrix self) -> double\n"
		""},
	 { "SbDPMatrix_det4", _wrap_SbDPMatrix_det4, METH_O, "SbDPMatrix_det4(SbDPMatrix self) -> double"},
	 { "SbDPMatrix_equals", _wrap_SbDPMatrix_equals, METH_VARARGS, "SbDPMatrix_equals(SbDPMatrix self, SbDPMatrix m, double tolerance) -> SbBool"},
	 { "SbDPMatrix_getValue", _wrap_SbDPMatrix_getValue, METH_VARARGS, "\n"
		"SbDPMatrix_getValue(SbDPMatrix self) -> SbDPMat const\n"
		"SbDPMatrix_getValue(SbDPMatrix self, SbDPMat & m)\n"
		""},
	 { "SbDPMatrix_identity", _wrap_SbDPMatrix_identity, METH_NOARGS, "SbDPMatrix_identity() -> SbDPMatrix"},
	 { "SbDPMatrix_setScale", _wrap_SbDPMatrix_setScale, METH_VARARGS, "\n"
		"SbDPMatrix_setScale(SbDPMatrix self, double const s)\n"
		"SbDPMatrix_setScale(SbDPMatrix self, SbVec3d s)\n"
		""},
	 { "SbDPMatrix_setTranslate", _wrap_SbDPMatrix_setTranslate, METH_VARARGS, "SbDPMatrix_setTranslate(SbDPMatrix self, SbVec3d t)"},
	 { "SbDPMatrix_setTransform", _wrap_SbDPMatrix_setTransform, METH_VARARGS, "\n"
		"SbDPMatrix_setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s)\n"
		"SbDPMatrix_setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)\n"
		"SbDPMatrix_setTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)\n"
		""},
	 { "SbDPMatrix_getTransform", _wrap_SbDPMatrix_getTransform, METH_VARARGS, "\n"
		"SbDPMatrix_getTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)\n"
		"SbDPMatrix_getTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)\n"
		""},
	 { "SbDPMatrix_factor", _wrap_SbDPMatrix_factor, METH_VARARGS, "SbDPMatrix_factor(SbDPMatrix self, SbDPMatrix r, SbVec3d s, SbDPMatrix u, SbVec3d t, SbDPMatrix proj) -> SbBool"},
	 { "SbDPMatrix_LUDecomposition", _wrap_SbDPMatrix_LUDecomposition, METH_VARARGS, "SbDPMatrix_LUDecomposition(SbDPMatrix self, int [4] index, double & d) -> SbBool"},
	 { "SbDPMatrix_LUBackSubstitution", _wrap_SbDPMatrix_LUBackSubstitution, METH_VARARGS, "SbDPMatrix_LUBackSubstitution(SbDPMatrix self, int [4] index, double [4] b)"},
	 { "SbDPMatrix_transpose", _wrap_SbDPMatrix_transpose, METH_O, "SbDPMatrix_transpose(SbDPMatrix self) -> SbDPMatrix"},
	 { "SbDPMatrix_multRight", _wrap_SbDPMatrix_multRight, METH_VARARGS, "SbDPMatrix_multRight(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"},
	 { "SbDPMatrix_multLeft", _wrap_SbDPMatrix_multLeft, METH_VARARGS, "SbDPMatrix_multLeft(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"},
	 { "SbDPMatrix_multMatrixVec", _wrap_SbDPMatrix_multMatrixVec, METH_VARARGS, "SbDPMatrix_multMatrixVec(SbDPMatrix self, SbVec3d src, SbVec3d dst)"},
	 { "SbDPMatrix_multDirMatrix", _wrap_SbDPMatrix_multDirMatrix, METH_VARARGS, "SbDPMatrix_multDirMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)"},
	 { "SbDPMatrix_multLineMatrix", _wrap_SbDPMatrix_multLineMatrix, METH_VARARGS, "SbDPMatrix_multLineMatrix(SbDPMatrix self, SbDPLine src, SbDPLine dst)"},
	 { "SbDPMatrix_multVecMatrix", _wrap_SbDPMatrix_multVecMatrix, METH_VARARGS, "\n"
		"SbDPMatrix_multVecMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)\n"
		"SbDPMatrix_multVecMatrix(SbDPMatrix self, SbVec4d src, SbVec4d dst)\n"
		""},
	 { "SbDPMatrix_output", _wrap_SbDPMatrix_output, METH_VARARGS, "SbDPMatrix_output(SbDPMatrix self, FILE * fp)"},
	 { "SbDPMatrix___imul__", _wrap_SbDPMatrix___imul__, METH_VARARGS, "SbDPMatrix___imul__(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"},
	 { "SbDPMatrix___mul__", _wrap_SbDPMatrix___mul__, METH_VARARGS, "\n"
		"SbDPMatrix___mul__(SbDPMatrix self, SbDPMatrix u) -> SbDPMatrix\n"
		"SbDPMatrix___mul__(SbDPMatrix self, SbVec3d u) -> SbVec3d\n"
		""},
	 { "SbDPMatrix___rmul__", _wrap_SbDPMatrix___rmul__, METH_VARARGS, "SbDPMatrix___rmul__(SbDPMatrix self, SbVec3d u) -> SbVec3d"},
	 { "SbDPMatrix___eq__", _wrap_SbDPMatrix___eq__, METH_VARARGS, "SbDPMatrix___eq__(SbDPMatrix self, SbDPMatrix u) -> int"},
	 { "SbDPMatrix___ne__", _wrap_SbDPMatrix___ne__, METH_VARARGS, "SbDPMatrix___ne__(SbDPMatrix self, SbDPMatrix u) -> int"},
	 { "SbDPMatrix_swigregister", SbDPMatrix_swigregister, METH_O, NULL},
	 { "SbDPMatrix_swiginit", SbDPMatrix_swiginit, METH_VARARGS, NULL},
	 { "SoGeo_init", _wrap_SoGeo_init, METH_NOARGS, "SoGeo_init()"},
	 { "SoGeo_toGD", _wrap_SoGeo_toGD, METH_VARARGS, "SoGeo_toGD(SbString originsystem, int const numoriginsys, SbVec3d origincoords) -> SbVec3d"},
	 { "SoGeo_fromGD", _wrap_SoGeo_fromGD, METH_VARARGS, "SoGeo_fromGD(SbVec3d gd, SbString tosystem, int const numtosys) -> SbVec3d"},
	 { "SoGeo_calculateDPTransform", _wrap_SoGeo_calculateDPTransform, METH_VARARGS, "SoGeo_calculateDPTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbDPMatrix"},
	 { "SoGeo_calculateTransform", _wrap_SoGeo_calculateTransform, METH_VARARGS, "SoGeo_calculateTransform(SbString originsystem, int const numoriginsys, SbVec3d origincoords, SbString localsystem, int const numlocalsys, SbVec3d localcoords) -> SbMatrix"},
	 { "new_SoGeo", _wrap_new_SoGeo, METH_NOARGS, "new_SoGeo() -> SoGeo"},
	 { "delete_SoGeo", _wrap_delete_SoGeo, METH_O, "delete_SoGeo(SoGeo self)"},
	 { "SoGeo_swigregister", SoGeo_swigregister, METH_O, NULL},
	 { "SoGeo_swiginit", SoGeo_swiginit, METH_VARARGS, NULL},
	 { "new_SoProto", _wrap_new_SoProto, METH_VARARGS, "SoProto(SbBool const externproto=0)"},
	 { "SoProto_setFetchExternProtoCallback", _wrap_SoProto_setFetchExternProtoCallback, METH_VARARGS, "SoProto_setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"},
	 { "SoProto_getTypeId", _wrap_SoProto_getTypeId, METH_O, "SoProto_getTypeId(SoProto self) -> SoType"},
	 { "SoProto_getClassTypeId", _wrap_SoProto_getClassTypeId, METH_NOARGS, "SoProto_getClassTypeId() -> SoType"},
	 { "SoProto_findProto", _wrap_SoProto_findProto, METH_O, "SoProto_findProto(SbName name) -> SoProto"},
	 { "SoProto_initClass", _wrap_SoProto_initClass, METH_NOARGS, "SoProto_initClass()"},
	 { "SoProto_createProtoInstance", _wrap_SoProto_createProtoInstance, METH_O, "SoProto_createProtoInstance(SoProto self) -> SoProtoInstance"},
	 { "SoProto_addISReference", _wrap_SoProto_addISReference, METH_VARARGS, "SoProto_addISReference(SoProto self, SoNode container, SbName fieldname, SbName interfacename)"},
	 { "SoProto_findISReference", _wrap_SoProto_findISReference, METH_VARARGS, "SoProto_findISReference(SoProto self, SoFieldContainer container, SbName fieldname) -> SbName"},
	 { "SoProto_addReference", _wrap_SoProto_addReference, METH_VARARGS, "SoProto_addReference(SoProto self, SbName name, SoBase base)"},
	 { "SoProto_removeReference", _wrap_SoProto_removeReference, METH_VARARGS, "SoProto_removeReference(SoProto self, SbName name)"},
	 { "SoProto_findReference", _wrap_SoProto_findReference, METH_VARARGS, "SoProto_findReference(SoProto self, SbName name) -> SoBase"},
	 { "SoProto_addRoute", _wrap_SoProto_addRoute, METH_VARARGS, "SoProto_addRoute(SoProto self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"},
	 { "SoProto_getProtoName", _wrap_SoProto_getProtoName, METH_O, "SoProto_getProtoName(SoProto self) -> SbName"},
	 { "SoProto_readInstance", _wrap_SoProto_readInstance, METH_VARARGS, "SoProto_readInstance(SoProto self, SoInput input, unsigned short flags) -> SbBool"},
	 { "SoProto_write", _wrap_SoProto_write, METH_VARARGS, "SoProto_write(SoProto self, SoWriteAction action)"},
	 { "SoProto_swigregister", SoProto_swigregister, METH_O, NULL},
	 { "SoProto_swiginit", SoProto_swiginit, METH_VARARGS, NULL},
	 { "SoProtoInstance_getClassTypeId", _wrap_SoProtoInstance_getClassTypeId, METH_NOARGS, "SoProtoInstance_getClassTypeId() -> SoType"},
	 { "SoProtoInstance_getTypeId", _wrap_SoProtoInstance_getTypeId, METH_O, "SoProtoInstance_getTypeId(SoProtoInstance self) -> SoType"},
	 { "SoProtoInstance_initClass", _wrap_SoProtoInstance_initClass, METH_NOARGS, "SoProtoInstance_initClass()"},
	 { "new_SoProtoInstance", _wrap_new_SoProtoInstance, METH_VARARGS, "new_SoProtoInstance(SoProto proto, SoFieldData deffielddata) -> SoProtoInstance"},
	 { "SoProtoInstance_findProtoInstance", _wrap_SoProtoInstance_findProtoInstance, METH_O, "SoProtoInstance_findProtoInstance(SoNode rootnode) -> SoProtoInstance"},
	 { "SoProtoInstance_setRootNode", _wrap_SoProtoInstance_setRootNode, METH_VARARGS, "SoProtoInstance_setRootNode(SoProtoInstance self, SoNode root)"},
	 { "SoProtoInstance_getRootNode", _wrap_SoProtoInstance_getRootNode, METH_O, "SoProtoInstance_getRootNode(SoProtoInstance self) -> SoNode"},
	 { "SoProtoInstance_getProtoDefinition", _wrap_SoProtoInstance_getProtoDefinition, METH_O, "SoProtoInstance_getProtoDefinition(SoProtoInstance self) -> SoProto"},
	 { "SoProtoInstance_getProtoName", _wrap_SoProtoInstance_getProtoName, METH_O, "SoProtoInstance_getProtoName(SoProtoInstance self) -> SbName"},
	 { "SoProtoInstance_write", _wrap_SoProtoInstance_write, METH_VARARGS, "SoProtoInstance_write(SoProtoInstance self, SoWriteAction action)"},
	 { "SoProtoInstance_swigregister", SoProtoInstance_swigregister, METH_O, NULL},
	 { "SoProtoInstance_swiginit", SoProtoInstance_swiginit, METH_VARARGS, NULL},
	 { "new_SoTranReceiver", _wrap_new_SoTranReceiver, METH_O, "new_SoTranReceiver(SoGroup root) -> SoTranReceiver"},
	 { "delete_SoTranReceiver", _wrap_delete_SoTranReceiver, METH_O, "delete_SoTranReceiver(SoTranReceiver self)"},
	 { "SoTranReceiver_interpret", _wrap_SoTranReceiver_interpret, METH_VARARGS, "SoTranReceiver_interpret(SoTranReceiver self, SoInput input) -> SbBool"},
	 { "SoTranReceiver_swigregister", SoTranReceiver_swigregister, METH_O, NULL},
	 { "SoTranReceiver_swiginit", SoTranReceiver_swiginit, METH_VARARGS, NULL},
	 { "new_SoTranSender", _wrap_new_SoTranSender, METH_O, "new_SoTranSender(SoOutput output) -> SoTranSender"},
	 { "delete_SoTranSender", _wrap_delete_SoTranSender, METH_O, "delete_SoTranSender(SoTranSender self)"},
	 { "SoTranSender_getOutput", _wrap_SoTranSender_getOutput, METH_O, "SoTranSender_getOutput(SoTranSender self) -> SoOutput"},
	 { "SoTranSender_insert", _wrap_SoTranSender_insert, METH_VARARGS, "\n"
		"SoTranSender_insert(SoTranSender self, SoNode node)\n"
		"SoTranSender_insert(SoTranSender self, SoNode node, SoNode parent, int n)\n"
		""},
	 { "SoTranSender_remove", _wrap_SoTranSender_remove, METH_VARARGS, "SoTranSender_remove(SoTranSender self, SoNode parent, int n)"},
	 { "SoTranSender_replace", _wrap_SoTranSender_replace, METH_VARARGS, "SoTranSender_replace(SoTranSender self, SoNode parent, int n, SoNode newnode)"},
	 { "SoTranSender_modify", _wrap_SoTranSender_modify, METH_VARARGS, "SoTranSender_modify(SoTranSender self, SoNode node)"},
	 { "SoTranSender_prepareToSend", _wrap_SoTranSender_prepareToSend, METH_O, "SoTranSender_prepareToSend(SoTranSender self)"},
	 { "SoTranSender_swigregister", SoTranSender_swigregister, METH_O, NULL},
	 { "SoTranSender_swiginit", SoTranSender_swiginit, METH_VARARGS, NULL},
	 { "SoAppearanceKit_getClassTypeId", _wrap_SoAppearanceKit_getClassTypeId, METH_NOARGS, "SoAppearanceKit_getClassTypeId() -> SoType"},
	 { "SoAppearanceKit_getTypeId", _wrap_SoAppearanceKit_getTypeId, METH_O, "SoAppearanceKit_getTypeId(SoAppearanceKit self) -> SoType"},
	 { "SoAppearanceKit_getClassNodekitCatalog", _wrap_SoAppearanceKit_getClassNodekitCatalog, METH_NOARGS, "SoAppearanceKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoAppearanceKit_getNodekitCatalog", _wrap_SoAppearanceKit_getNodekitCatalog, METH_O, "SoAppearanceKit_getNodekitCatalog(SoAppearanceKit self) -> SoNodekitCatalog"},
	 { "new_SoAppearanceKit", _wrap_new_SoAppearanceKit, METH_NOARGS, "new_SoAppearanceKit() -> SoAppearanceKit"},
	 { "SoAppearanceKit_initClass", _wrap_SoAppearanceKit_initClass, METH_NOARGS, "SoAppearanceKit_initClass()"},
	 { "SoAppearanceKit_swigregister", SoAppearanceKit_swigregister, METH_O, NULL},
	 { "SoAppearanceKit_swiginit", SoAppearanceKit_swiginit, METH_VARARGS, NULL},
	 { "SoCameraKit_getClassTypeId", _wrap_SoCameraKit_getClassTypeId, METH_NOARGS, "SoCameraKit_getClassTypeId() -> SoType"},
	 { "SoCameraKit_getTypeId", _wrap_SoCameraKit_getTypeId, METH_O, "SoCameraKit_getTypeId(SoCameraKit self) -> SoType"},
	 { "SoCameraKit_getClassNodekitCatalog", _wrap_SoCameraKit_getClassNodekitCatalog, METH_NOARGS, "SoCameraKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoCameraKit_getNodekitCatalog", _wrap_SoCameraKit_getNodekitCatalog, METH_O, "SoCameraKit_getNodekitCatalog(SoCameraKit self) -> SoNodekitCatalog"},
	 { "new_SoCameraKit", _wrap_new_SoCameraKit, METH_NOARGS, "new_SoCameraKit() -> SoCameraKit"},
	 { "SoCameraKit_initClass", _wrap_SoCameraKit_initClass, METH_NOARGS, "SoCameraKit_initClass()"},
	 { "SoCameraKit_swigregister", SoCameraKit_swigregister, METH_O, NULL},
	 { "SoCameraKit_swiginit", SoCameraKit_swiginit, METH_VARARGS, NULL},
	 { "SoLightKit_getClassTypeId", _wrap_SoLightKit_getClassTypeId, METH_NOARGS, "SoLightKit_getClassTypeId() -> SoType"},
	 { "SoLightKit_getTypeId", _wrap_SoLightKit_getTypeId, METH_O, "SoLightKit_getTypeId(SoLightKit self) -> SoType"},
	 { "SoLightKit_getClassNodekitCatalog", _wrap_SoLightKit_getClassNodekitCatalog, METH_NOARGS, "SoLightKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoLightKit_getNodekitCatalog", _wrap_SoLightKit_getNodekitCatalog, METH_O, "SoLightKit_getNodekitCatalog(SoLightKit self) -> SoNodekitCatalog"},
	 { "new_SoLightKit", _wrap_new_SoLightKit, METH_NOARGS, "new_SoLightKit() -> SoLightKit"},
	 { "SoLightKit_initClass", _wrap_SoLightKit_initClass, METH_NOARGS, "SoLightKit_initClass()"},
	 { "SoLightKit_swigregister", SoLightKit_swigregister, METH_O, NULL},
	 { "SoLightKit_swiginit", SoLightKit_swiginit, METH_VARARGS, NULL},
	 { "SoNodeKit_init", _wrap_SoNodeKit_init, METH_NOARGS, "SoNodeKit_init()"},
	 { "new_SoNodeKit", _wrap_new_SoNodeKit, METH_NOARGS, "new_SoNodeKit() -> SoNodeKit"},
	 { "delete_SoNodeKit", _wrap_delete_SoNodeKit, METH_O, "delete_SoNodeKit(SoNodeKit self)"},
	 { "SoNodeKit_swigregister", SoNodeKit_swigregister, METH_O, NULL},
	 { "SoNodeKit_swiginit", SoNodeKit_swiginit, METH_VARARGS, NULL},
	 { "SoSceneKit_getClassTypeId", _wrap_SoSceneKit_getClassTypeId, METH_NOARGS, "SoSceneKit_getClassTypeId() -> SoType"},
	 { "SoSceneKit_getTypeId", _wrap_SoSceneKit_getTypeId, METH_O, "SoSceneKit_getTypeId(SoSceneKit self) -> SoType"},
	 { "SoSceneKit_getClassNodekitCatalog", _wrap_SoSceneKit_getClassNodekitCatalog, METH_NOARGS, "SoSceneKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoSceneKit_getNodekitCatalog", _wrap_SoSceneKit_getNodekitCatalog, METH_O, "SoSceneKit_getNodekitCatalog(SoSceneKit self) -> SoNodekitCatalog"},
	 { "SoSceneKit_initClass", _wrap_SoSceneKit_initClass, METH_NOARGS, "SoSceneKit_initClass()"},
	 { "new_SoSceneKit", _wrap_new_SoSceneKit, METH_NOARGS, "new_SoSceneKit() -> SoSceneKit"},
	 { "SoSceneKit_getCameraNumber", _wrap_SoSceneKit_getCameraNumber, METH_O, "SoSceneKit_getCameraNumber(SoSceneKit self) -> int"},
	 { "SoSceneKit_setCameraNumber", _wrap_SoSceneKit_setCameraNumber, METH_VARARGS, "SoSceneKit_setCameraNumber(SoSceneKit self, int camNum)"},
	 { "SoSceneKit_affectsState", _wrap_SoSceneKit_affectsState, METH_O, "SoSceneKit_affectsState(SoSceneKit self) -> SbBool"},
	 { "SoSceneKit_swigregister", SoSceneKit_swigregister, METH_O, NULL},
	 { "SoSceneKit_swiginit", SoSceneKit_swiginit, METH_VARARGS, NULL},
	 { "SoSeparatorKit_getClassTypeId", _wrap_SoSeparatorKit_getClassTypeId, METH_NOARGS, "SoSeparatorKit_getClassTypeId() -> SoType"},
	 { "SoSeparatorKit_getTypeId", _wrap_SoSeparatorKit_getTypeId, METH_O, "SoSeparatorKit_getTypeId(SoSeparatorKit self) -> SoType"},
	 { "SoSeparatorKit_getClassNodekitCatalog", _wrap_SoSeparatorKit_getClassNodekitCatalog, METH_NOARGS, "SoSeparatorKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoSeparatorKit_getNodekitCatalog", _wrap_SoSeparatorKit_getNodekitCatalog, METH_O, "SoSeparatorKit_getNodekitCatalog(SoSeparatorKit self) -> SoNodekitCatalog"},
	 { "new_SoSeparatorKit", _wrap_new_SoSeparatorKit, METH_NOARGS, "new_SoSeparatorKit() -> SoSeparatorKit"},
	 { "SoSeparatorKit_renderCaching_set", _wrap_SoSeparatorKit_renderCaching_set, METH_VARARGS, "SoSeparatorKit_renderCaching_set(SoSeparatorKit self, SoSFEnum renderCaching)"},
	 { "SoSeparatorKit_renderCaching_get", _wrap_SoSeparatorKit_renderCaching_get, METH_O, "SoSeparatorKit_renderCaching_get(SoSeparatorKit self) -> SoSFEnum"},
	 { "SoSeparatorKit_boundingBoxCaching_set", _wrap_SoSeparatorKit_boundingBoxCaching_set, METH_VARARGS, "SoSeparatorKit_boundingBoxCaching_set(SoSeparatorKit self, SoSFEnum boundingBoxCaching)"},
	 { "SoSeparatorKit_boundingBoxCaching_get", _wrap_SoSeparatorKit_boundingBoxCaching_get, METH_O, "SoSeparatorKit_boundingBoxCaching_get(SoSeparatorKit self) -> SoSFEnum"},
	 { "SoSeparatorKit_renderCulling_set", _wrap_SoSeparatorKit_renderCulling_set, METH_VARARGS, "SoSeparatorKit_renderCulling_set(SoSeparatorKit self, SoSFEnum renderCulling)"},
	 { "SoSeparatorKit_renderCulling_get", _wrap_SoSeparatorKit_renderCulling_get, METH_O, "SoSeparatorKit_renderCulling_get(SoSeparatorKit self) -> SoSFEnum"},
	 { "SoSeparatorKit_pickCulling_set", _wrap_SoSeparatorKit_pickCulling_set, METH_VARARGS, "SoSeparatorKit_pickCulling_set(SoSeparatorKit self, SoSFEnum pickCulling)"},
	 { "SoSeparatorKit_pickCulling_get", _wrap_SoSeparatorKit_pickCulling_get, METH_O, "SoSeparatorKit_pickCulling_get(SoSeparatorKit self) -> SoSFEnum"},
	 { "SoSeparatorKit_initClass", _wrap_SoSeparatorKit_initClass, METH_NOARGS, "SoSeparatorKit_initClass()"},
	 { "SoSeparatorKit_swigregister", SoSeparatorKit_swigregister, METH_O, NULL},
	 { "SoSeparatorKit_swiginit", SoSeparatorKit_swiginit, METH_VARARGS, NULL},
	 { "SoShapeKit_getClassTypeId", _wrap_SoShapeKit_getClassTypeId, METH_NOARGS, "SoShapeKit_getClassTypeId() -> SoType"},
	 { "SoShapeKit_getTypeId", _wrap_SoShapeKit_getTypeId, METH_O, "SoShapeKit_getTypeId(SoShapeKit self) -> SoType"},
	 { "SoShapeKit_getClassNodekitCatalog", _wrap_SoShapeKit_getClassNodekitCatalog, METH_NOARGS, "SoShapeKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoShapeKit_getNodekitCatalog", _wrap_SoShapeKit_getNodekitCatalog, METH_O, "SoShapeKit_getNodekitCatalog(SoShapeKit self) -> SoNodekitCatalog"},
	 { "new_SoShapeKit", _wrap_new_SoShapeKit, METH_NOARGS, "new_SoShapeKit() -> SoShapeKit"},
	 { "SoShapeKit_initClass", _wrap_SoShapeKit_initClass, METH_NOARGS, "SoShapeKit_initClass()"},
	 { "SoShapeKit_swigregister", SoShapeKit_swigregister, METH_O, NULL},
	 { "SoShapeKit_swiginit", SoShapeKit_swiginit, METH_VARARGS, NULL},
	 { "SoWrapperKit_getClassTypeId", _wrap_SoWrapperKit_getClassTypeId, METH_NOARGS, "SoWrapperKit_getClassTypeId() -> SoType"},
	 { "SoWrapperKit_getTypeId", _wrap_SoWrapperKit_getTypeId, METH_O, "SoWrapperKit_getTypeId(SoWrapperKit self) -> SoType"},
	 { "SoWrapperKit_getClassNodekitCatalog", _wrap_SoWrapperKit_getClassNodekitCatalog, METH_NOARGS, "SoWrapperKit_getClassNodekitCatalog() -> SoNodekitCatalog"},
	 { "SoWrapperKit_getNodekitCatalog", _wrap_SoWrapperKit_getNodekitCatalog, METH_O, "SoWrapperKit_getNodekitCatalog(SoWrapperKit self) -> SoNodekitCatalog"},
	 { "new_SoWrapperKit", _wrap_new_SoWrapperKit, METH_NOARGS, "new_SoWrapperKit() -> SoWrapperKit"},
	 { "SoWrapperKit_initClass", _wrap_SoWrapperKit_initClass, METH_NOARGS, "SoWrapperKit_initClass()"},
	 { "SoWrapperKit_swigregister", SoWrapperKit_swigregister, METH_O, NULL},
	 { "SoWrapperKit_swiginit", SoWrapperKit_swiginit, METH_VARARGS, NULL},
	 { "SoGroup_getClassTypeId", _wrap_SoGroup_getClassTypeId, METH_NOARGS, "SoGroup_getClassTypeId() -> SoType"},
	 { "SoGroup_getTypeId", _wrap_SoGroup_getTypeId, METH_O, "SoGroup_getTypeId(SoGroup self) -> SoType"},
	 { "SoGroup_initClass", _wrap_SoGroup_initClass, METH_NOARGS, "SoGroup_initClass()"},
	 { "new_SoGroup", _wrap_new_SoGroup, METH_VARARGS, "\n"
		"SoGroup()\n"
		"new_SoGroup(int nchildren) -> SoGroup\n"
		""},
	 { "SoGroup_addChild", _wrap_SoGroup_addChild, METH_VARARGS, "SoGroup_addChild(SoGroup self, SoNode node)"},
	 { "SoGroup_insertChild", _wrap_SoGroup_insertChild, METH_VARARGS, "SoGroup_insertChild(SoGroup self, SoNode child, int newchildindex)"},
	 { "SoGroup_getChild", _wrap_SoGroup_getChild, METH_VARARGS, "SoGroup_getChild(SoGroup self, int index) -> SoNode"},
	 { "SoGroup_findChild", _wrap_SoGroup_findChild, METH_VARARGS, "SoGroup_findChild(SoGroup self, SoNode node) -> int"},
	 { "SoGroup_getNumChildren", _wrap_SoGroup_getNumChildren, METH_O, "SoGroup_getNumChildren(SoGroup self) -> int"},
	 { "SoGroup_removeChild", _wrap_SoGroup_removeChild, METH_VARARGS, "\n"
		"SoGroup_removeChild(SoGroup self, int childindex)\n"
		"SoGroup_removeChild(SoGroup self, SoNode child)\n"
		""},
	 { "SoGroup_removeAllChildren", _wrap_SoGroup_removeAllChildren, METH_O, "SoGroup_removeAllChildren(SoGroup self)"},
	 { "SoGroup_replaceChild", _wrap_SoGroup_replaceChild, METH_VARARGS, "\n"
		"SoGroup_replaceChild(SoGroup self, int index, SoNode newchild)\n"
		"SoGroup_replaceChild(SoGroup self, SoNode oldchild, SoNode newchild)\n"
		""},
	 { "SoGroup_doAction", _wrap_SoGroup_doAction, METH_VARARGS, "SoGroup_doAction(SoGroup self, SoAction action)"},
	 { "SoGroup_GLRender", _wrap_SoGroup_GLRender, METH_VARARGS, "SoGroup_GLRender(SoGroup self, SoGLRenderAction action)"},
	 { "SoGroup_callback", _wrap_SoGroup_callback, METH_VARARGS, "SoGroup_callback(SoGroup self, SoCallbackAction action)"},
	 { "SoGroup_getBoundingBox", _wrap_SoGroup_getBoundingBox, METH_VARARGS, "SoGroup_getBoundingBox(SoGroup self, SoGetBoundingBoxAction action)"},
	 { "SoGroup_getMatrix", _wrap_SoGroup_getMatrix, METH_VARARGS, "SoGroup_getMatrix(SoGroup self, SoGetMatrixAction action)"},
	 { "SoGroup_handleEvent", _wrap_SoGroup_handleEvent, METH_VARARGS, "SoGroup_handleEvent(SoGroup self, SoHandleEventAction action)"},
	 { "SoGroup_pick", _wrap_SoGroup_pick, METH_VARARGS, "SoGroup_pick(SoGroup self, SoPickAction action)"},
	 { "SoGroup_search", _wrap_SoGroup_search, METH_VARARGS, "SoGroup_search(SoGroup self, SoSearchAction action)"},
	 { "SoGroup_write", _wrap_SoGroup_write, METH_VARARGS, "SoGroup_write(SoGroup self, SoWriteAction action)"},
	 { "SoGroup_getPrimitiveCount", _wrap_SoGroup_getPrimitiveCount, METH_VARARGS, "SoGroup_getPrimitiveCount(SoGroup self, SoGetPrimitiveCountAction action)"},
	 { "SoGroup_audioRender", _wrap_SoGroup_audioRender, METH_VARARGS, "SoGroup_audioRender(SoGroup self, SoAudioRenderAction action)"},
	 { "SoGroup_getChildren", _wrap_SoGroup_getChildren, METH_O, "SoGroup_getChildren(SoGroup self) -> SoChildList"},
	 { "SoGroup_addWriteReference", _wrap_SoGroup_addWriteReference, METH_VARARGS, "SoGroup_addWriteReference(SoGroup self, SoOutput out, SbBool isfromfield=0)"},
	 { "SoGroup___len__", _wrap_SoGroup___len__, METH_O, "SoGroup___len__(SoGroup self) -> int"},
	 { "SoGroup___contains__", _wrap_SoGroup___contains__, METH_VARARGS, "SoGroup___contains__(SoGroup self, SoNode node) -> int"},
	 { "SoGroup___getitem__", _wrap_SoGroup___getitem__, METH_VARARGS, "SoGroup___getitem__(SoGroup self, int index) -> SoNode"},
	 { "SoGroup_swigregister", SoGroup_swigregister, METH_O, NULL},
	 { "SoGroup_swiginit", SoGroup_swiginit, METH_VARARGS, NULL},
	 { "SoSeparator_getClassTypeId", _wrap_SoSeparator_getClassTypeId, METH_NOARGS, "SoSeparator_getClassTypeId() -> SoType"},
	 { "SoSeparator_getTypeId", _wrap_SoSeparator_getTypeId, METH_O, "SoSeparator_getTypeId(SoSeparator self) -> SoType"},
	 { "SoSeparator_initClass", _wrap_SoSeparator_initClass, METH_NOARGS, "SoSeparator_initClass()"},
	 { "new_SoSeparator", _wrap_new_SoSeparator, METH_VARARGS, "\n"
		"SoSeparator()\n"
		"new_SoSeparator(int const nchildren) -> SoSeparator\n"
		""},
	 { "SoSeparator_renderCaching_set", _wrap_SoSeparator_renderCaching_set, METH_VARARGS, "SoSeparator_renderCaching_set(SoSeparator self, SoSFEnum renderCaching)"},
	 { "SoSeparator_renderCaching_get", _wrap_SoSeparator_renderCaching_get, METH_O, "SoSeparator_renderCaching_get(SoSeparator self) -> SoSFEnum"},
	 { "SoSeparator_boundingBoxCaching_set", _wrap_SoSeparator_boundingBoxCaching_set, METH_VARARGS, "SoSeparator_boundingBoxCaching_set(SoSeparator self, SoSFEnum boundingBoxCaching)"},
	 { "SoSeparator_boundingBoxCaching_get", _wrap_SoSeparator_boundingBoxCaching_get, METH_O, "SoSeparator_boundingBoxCaching_get(SoSeparator self) -> SoSFEnum"},
	 { "SoSeparator_renderCulling_set", _wrap_SoSeparator_renderCulling_set, METH_VARARGS, "SoSeparator_renderCulling_set(SoSeparator self, SoSFEnum renderCulling)"},
	 { "SoSeparator_renderCulling_get", _wrap_SoSeparator_renderCulling_get, METH_O, "SoSeparator_renderCulling_get(SoSeparator self) -> SoSFEnum"},
	 { "SoSeparator_pickCulling_set", _wrap_SoSeparator_pickCulling_set, METH_VARARGS, "SoSeparator_pickCulling_set(SoSeparator self, SoSFEnum pickCulling)"},
	 { "SoSeparator_pickCulling_get", _wrap_SoSeparator_pickCulling_get, METH_O, "SoSeparator_pickCulling_get(SoSeparator self) -> SoSFEnum"},
	 { "SoSeparator_doAction", _wrap_SoSeparator_doAction, METH_VARARGS, "SoSeparator_doAction(SoSeparator self, SoAction action)"},
	 { "SoSeparator_GLRender", _wrap_SoSeparator_GLRender, METH_VARARGS, "SoSeparator_GLRender(SoSeparator self, SoGLRenderAction action)"},
	 { "SoSeparator_GLRenderBelowPath", _wrap_SoSeparator_GLRenderBelowPath, METH_VARARGS, "SoSeparator_GLRenderBelowPath(SoSeparator self, SoGLRenderAction action)"},
	 { "SoSeparator_GLRenderInPath", _wrap_SoSeparator_GLRenderInPath, METH_VARARGS, "SoSeparator_GLRenderInPath(SoSeparator self, SoGLRenderAction action)"},
	 { "SoSeparator_GLRenderOffPath", _wrap_SoSeparator_GLRenderOffPath, METH_VARARGS, "SoSeparator_GLRenderOffPath(SoSeparator self, SoGLRenderAction action)"},
	 { "SoSeparator_callback", _wrap_SoSeparator_callback, METH_VARARGS, "SoSeparator_callback(SoSeparator self, SoCallbackAction action)"},
	 { "SoSeparator_getBoundingBox", _wrap_SoSeparator_getBoundingBox, METH_VARARGS, "SoSeparator_getBoundingBox(SoSeparator self, SoGetBoundingBoxAction action)"},
	 { "SoSeparator_getMatrix", _wrap_SoSeparator_getMatrix, METH_VARARGS, "SoSeparator_getMatrix(SoSeparator self, SoGetMatrixAction action)"},
	 { "SoSeparator_handleEvent", _wrap_SoSeparator_handleEvent, METH_VARARGS, "SoSeparator_handleEvent(SoSeparator self, SoHandleEventAction action)"},
	 { "SoSeparator_rayPick", _wrap_SoSeparator_rayPick, METH_VARARGS, "SoSeparator_rayPick(SoSeparator self, SoRayPickAction action)"},
	 { "SoSeparator_search", _wrap_SoSeparator_search, METH_VARARGS, "SoSeparator_search(SoSeparator self, SoSearchAction action)"},
	 { "SoSeparator_getPrimitiveCount", _wrap_SoSeparator_getPrimitiveCount, METH_VARARGS, "SoSeparator_getPrimitiveCount(SoSeparator self, SoGetPrimitiveCountAction action)"},
	 { "SoSeparator_audioRender", _wrap_SoSeparator_audioRender, METH_VARARGS, "SoSeparator_audioRender(SoSeparator self, SoAudioRenderAction action)"},
	 { "SoSeparator_notify", _wrap_SoSeparator_notify, METH_VARARGS, "SoSeparator_notify(SoSeparator self, SoNotList nl)"},
	 { "SoSeparator_setNumRenderCaches", _wrap_SoSeparator_setNumRenderCaches, METH_O, "SoSeparator_setNumRenderCaches(int const howmany)"},
	 { "SoSeparator_getNumRenderCaches", _wrap_SoSeparator_getNumRenderCaches, METH_NOARGS, "SoSeparator_getNumRenderCaches() -> int"},
	 { "SoSeparator_affectsState", _wrap_SoSeparator_affectsState, METH_O, "SoSeparator_affectsState(SoSeparator self) -> SbBool"},
	 { "SoSeparator_swigregister", SoSeparator_swigregister, METH_O, NULL},
	 { "SoSeparator_swiginit", SoSeparator_swiginit, METH_VARARGS, NULL},
	 { "SoAnnotation_getClassTypeId", _wrap_SoAnnotation_getClassTypeId, METH_NOARGS, "SoAnnotation_getClassTypeId() -> SoType"},
	 { "SoAnnotation_getTypeId", _wrap_SoAnnotation_getTypeId, METH_O, "SoAnnotation_getTypeId(SoAnnotation self) -> SoType"},
	 { "SoAnnotation_initClass", _wrap_SoAnnotation_initClass, METH_NOARGS, "SoAnnotation_initClass()"},
	 { "new_SoAnnotation", _wrap_new_SoAnnotation, METH_NOARGS, "new_SoAnnotation() -> SoAnnotation"},
	 { "SoAnnotation_GLRender", _wrap_SoAnnotation_GLRender, METH_VARARGS, "SoAnnotation_GLRender(SoAnnotation self, SoGLRenderAction action)"},
	 { "SoAnnotation_GLRenderBelowPath", _wrap_SoAnnotation_GLRenderBelowPath, METH_VARARGS, "SoAnnotation_GLRenderBelowPath(SoAnnotation self, SoGLRenderAction action)"},
	 { "SoAnnotation_GLRenderInPath", _wrap_SoAnnotation_GLRenderInPath, METH_VARARGS, "SoAnnotation_GLRenderInPath(SoAnnotation self, SoGLRenderAction action)"},
	 { "SoAnnotation_GLRenderOffPath", _wrap_SoAnnotation_GLRenderOffPath, METH_VARARGS, "SoAnnotation_GLRenderOffPath(SoAnnotation self, SoGLRenderAction action)"},
	 { "SoAnnotation_swigregister", SoAnnotation_swigregister, METH_O, NULL},
	 { "SoAnnotation_swiginit", SoAnnotation_swiginit, METH_VARARGS, NULL},
	 { "SoAntiSquish_getClassTypeId", _wrap_SoAntiSquish_getClassTypeId, METH_NOARGS, "SoAntiSquish_getClassTypeId() -> SoType"},
	 { "SoAntiSquish_getTypeId", _wrap_SoAntiSquish_getTypeId, METH_O, "SoAntiSquish_getTypeId(SoAntiSquish self) -> SoType"},
	 { "SoAntiSquish_initClass", _wrap_SoAntiSquish_initClass, METH_NOARGS, "SoAntiSquish_initClass()"},
	 { "new_SoAntiSquish", _wrap_new_SoAntiSquish, METH_NOARGS, "new_SoAntiSquish() -> SoAntiSquish"},
	 { "SoAntiSquish_sizing_set", _wrap_SoAntiSquish_sizing_set, METH_VARARGS, "SoAntiSquish_sizing_set(SoAntiSquish self, SoSFEnum sizing)"},
	 { "SoAntiSquish_sizing_get", _wrap_SoAntiSquish_sizing_get, METH_O, "SoAntiSquish_sizing_get(SoAntiSquish self) -> SoSFEnum"},
	 { "SoAntiSquish_recalcAlways_set", _wrap_SoAntiSquish_recalcAlways_set, METH_VARARGS, "SoAntiSquish_recalcAlways_set(SoAntiSquish self, SoSFBool recalcAlways)"},
	 { "SoAntiSquish_recalcAlways_get", _wrap_SoAntiSquish_recalcAlways_get, METH_O, "SoAntiSquish_recalcAlways_get(SoAntiSquish self) -> SoSFBool"},
	 { "SoAntiSquish_recalc", _wrap_SoAntiSquish_recalc, METH_O, "SoAntiSquish_recalc(SoAntiSquish self)"},
	 { "SoAntiSquish_doAction", _wrap_SoAntiSquish_doAction, METH_VARARGS, "SoAntiSquish_doAction(SoAntiSquish self, SoAction action)"},
	 { "SoAntiSquish_swigregister", SoAntiSquish_swigregister, METH_O, NULL},
	 { "SoAntiSquish_swiginit", SoAntiSquish_swiginit, METH_VARARGS, NULL},
	 { "SoArray_getClassTypeId", _wrap_SoArray_getClassTypeId, METH_NOARGS, "SoArray_getClassTypeId() -> SoType"},
	 { "SoArray_getTypeId", _wrap_SoArray_getTypeId, METH_O, "SoArray_getTypeId(SoArray self) -> SoType"},
	 { "SoArray_initClass", _wrap_SoArray_initClass, METH_NOARGS, "SoArray_initClass()"},
	 { "new_SoArray", _wrap_new_SoArray, METH_NOARGS, "new_SoArray() -> SoArray"},
	 { "SoArray_origin_set", _wrap_SoArray_origin_set, METH_VARARGS, "SoArray_origin_set(SoArray self, SoSFEnum origin)"},
	 { "SoArray_origin_get", _wrap_SoArray_origin_get, METH_O, "SoArray_origin_get(SoArray self) -> SoSFEnum"},
	 { "SoArray_numElements1_set", _wrap_SoArray_numElements1_set, METH_VARARGS, "SoArray_numElements1_set(SoArray self, SoSFShort numElements1)"},
	 { "SoArray_numElements1_get", _wrap_SoArray_numElements1_get, METH_O, "SoArray_numElements1_get(SoArray self) -> SoSFShort"},
	 { "SoArray_numElements2_set", _wrap_SoArray_numElements2_set, METH_VARARGS, "SoArray_numElements2_set(SoArray self, SoSFShort numElements2)"},
	 { "SoArray_numElements2_get", _wrap_SoArray_numElements2_get, METH_O, "SoArray_numElements2_get(SoArray self) -> SoSFShort"},
	 { "SoArray_numElements3_set", _wrap_SoArray_numElements3_set, METH_VARARGS, "SoArray_numElements3_set(SoArray self, SoSFShort numElements3)"},
	 { "SoArray_numElements3_get", _wrap_SoArray_numElements3_get, METH_O, "SoArray_numElements3_get(SoArray self) -> SoSFShort"},
	 { "SoArray_separation1_set", _wrap_SoArray_separation1_set, METH_VARARGS, "SoArray_separation1_set(SoArray self, SoSFVec3f separation1)"},
	 { "SoArray_separation1_get", _wrap_SoArray_separation1_get, METH_O, "SoArray_separation1_get(SoArray self) -> SoSFVec3f"},
	 { "SoArray_separation2_set", _wrap_SoArray_separation2_set, METH_VARARGS, "SoArray_separation2_set(SoArray self, SoSFVec3f separation2)"},
	 { "SoArray_separation2_get", _wrap_SoArray_separation2_get, METH_O, "SoArray_separation2_get(SoArray self) -> SoSFVec3f"},
	 { "SoArray_separation3_set", _wrap_SoArray_separation3_set, METH_VARARGS, "SoArray_separation3_set(SoArray self, SoSFVec3f separation3)"},
	 { "SoArray_separation3_get", _wrap_SoArray_separation3_get, METH_O, "SoArray_separation3_get(SoArray self) -> SoSFVec3f"},
	 { "SoArray_affectsState", _wrap_SoArray_affectsState, METH_O, "SoArray_affectsState(SoArray self) -> SbBool"},
	 { "SoArray_doAction", _wrap_SoArray_doAction, METH_VARARGS, "SoArray_doAction(SoArray self, SoAction action)"},
	 { "SoArray_callback", _wrap_SoArray_callback, METH_VARARGS, "SoArray_callback(SoArray self, SoCallbackAction action)"},
	 { "SoArray_GLRender", _wrap_SoArray_GLRender, METH_VARARGS, "SoArray_GLRender(SoArray self, SoGLRenderAction action)"},
	 { "SoArray_pick", _wrap_SoArray_pick, METH_VARARGS, "SoArray_pick(SoArray self, SoPickAction action)"},
	 { "SoArray_getBoundingBox", _wrap_SoArray_getBoundingBox, METH_VARARGS, "SoArray_getBoundingBox(SoArray self, SoGetBoundingBoxAction action)"},
	 { "SoArray_handleEvent", _wrap_SoArray_handleEvent, METH_VARARGS, "SoArray_handleEvent(SoArray self, SoHandleEventAction action)"},
	 { "SoArray_getMatrix", _wrap_SoArray_getMatrix, METH_VARARGS, "SoArray_getMatrix(SoArray self, SoGetMatrixAction action)"},
	 { "SoArray_search", _wrap_SoArray_search, METH_VARARGS, "SoArray_search(SoArray self, SoSearchAction action)"},
	 { "SoArray_getPrimitiveCount", _wrap_SoArray_getPrimitiveCount, METH_VARARGS, "SoArray_getPrimitiveCount(SoArray self, SoGetPrimitiveCountAction action)"},
	 { "SoArray_audioRender", _wrap_SoArray_audioRender, METH_VARARGS, "SoArray_audioRender(SoArray self, SoAudioRenderAction action)"},
	 { "SoArray_swigregister", SoArray_swigregister, METH_O, NULL},
	 { "SoArray_swiginit", SoArray_swiginit, METH_VARARGS, NULL},
	 { "SoAsciiText_getClassTypeId", _wrap_SoAsciiText_getClassTypeId, METH_NOARGS, "SoAsciiText_getClassTypeId() -> SoType"},
	 { "SoAsciiText_getTypeId", _wrap_SoAsciiText_getTypeId, METH_O, "SoAsciiText_getTypeId(SoAsciiText self) -> SoType"},
	 { "SoAsciiText_initClass", _wrap_SoAsciiText_initClass, METH_NOARGS, "SoAsciiText_initClass()"},
	 { "new_SoAsciiText", _wrap_new_SoAsciiText, METH_NOARGS, "new_SoAsciiText() -> SoAsciiText"},
	 { "SoAsciiText_string_set", _wrap_SoAsciiText_string_set, METH_VARARGS, "SoAsciiText_string_set(SoAsciiText self, SoMFString string)"},
	 { "SoAsciiText_string_get", _wrap_SoAsciiText_string_get, METH_O, "SoAsciiText_string_get(SoAsciiText self) -> SoMFString"},
	 { "SoAsciiText_spacing_set", _wrap_SoAsciiText_spacing_set, METH_VARARGS, "SoAsciiText_spacing_set(SoAsciiText self, SoSFFloat spacing)"},
	 { "SoAsciiText_spacing_get", _wrap_SoAsciiText_spacing_get, METH_O, "SoAsciiText_spacing_get(SoAsciiText self) -> SoSFFloat"},
	 { "SoAsciiText_justification_set", _wrap_SoAsciiText_justification_set, METH_VARARGS, "SoAsciiText_justification_set(SoAsciiText self, SoSFEnum justification)"},
	 { "SoAsciiText_justification_get", _wrap_SoAsciiText_justification_get, METH_O, "SoAsciiText_justification_get(SoAsciiText self) -> SoSFEnum"},
	 { "SoAsciiText_width_set", _wrap_SoAsciiText_width_set, METH_VARARGS, "SoAsciiText_width_set(SoAsciiText self, SoMFFloat width)"},
	 { "SoAsciiText_width_get", _wrap_SoAsciiText_width_get, METH_O, "SoAsciiText_width_get(SoAsciiText self) -> SoMFFloat"},
	 { "SoAsciiText_GLRender", _wrap_SoAsciiText_GLRender, METH_VARARGS, "SoAsciiText_GLRender(SoAsciiText self, SoGLRenderAction action)"},
	 { "SoAsciiText_getPrimitiveCount", _wrap_SoAsciiText_getPrimitiveCount, METH_VARARGS, "SoAsciiText_getPrimitiveCount(SoAsciiText self, SoGetPrimitiveCountAction action)"},
	 { "SoAsciiText_swigregister", SoAsciiText_swigregister, METH_O, NULL},
	 { "SoAsciiText_swiginit", SoAsciiText_swiginit, METH_VARARGS, NULL},
	 { "SoBaseColor_getClassTypeId", _wrap_SoBaseColor_getClassTypeId, METH_NOARGS, "SoBaseColor_getClassTypeId() -> SoType"},
	 { "SoBaseColor_getTypeId", _wrap_SoBaseColor_getTypeId, METH_O, "SoBaseColor_getTypeId(SoBaseColor self) -> SoType"},
	 { "SoBaseColor_initClass", _wrap_SoBaseColor_initClass, METH_NOARGS, "SoBaseColor_initClass()"},
	 { "new_SoBaseColor", _wrap_new_SoBaseColor, METH_NOARGS, "new_SoBaseColor() -> SoBaseColor"},
	 { "SoBaseColor_rgb_set", _wrap_SoBaseColor_rgb_set, METH_VARARGS, "SoBaseColor_rgb_set(SoBaseColor self, SoMFColor rgb)"},
	 { "SoBaseColor_rgb_get", _wrap_SoBaseColor_rgb_get, METH_O, "SoBaseColor_rgb_get(SoBaseColor self) -> SoMFColor"},
	 { "SoBaseColor_doAction", _wrap_SoBaseColor_doAction, METH_VARARGS, "SoBaseColor_doAction(SoBaseColor self, SoAction action)"},
	 { "SoBaseColor_GLRender", _wrap_SoBaseColor_GLRender, METH_VARARGS, "SoBaseColor_GLRender(SoBaseColor self, SoGLRenderAction action)"},
	 { "SoBaseColor_callback", _wrap_SoBaseColor_callback, METH_VARARGS, "SoBaseColor_callback(SoBaseColor self, SoCallbackAction action)"},
	 { "SoBaseColor_swigregister", SoBaseColor_swigregister, METH_O, NULL},
	 { "SoBaseColor_swiginit", SoBaseColor_swiginit, METH_VARARGS, NULL},
	 { "SoSwitch_getClassTypeId", _wrap_SoSwitch_getClassTypeId, METH_NOARGS, "SoSwitch_getClassTypeId() -> SoType"},
	 { "SoSwitch_getTypeId", _wrap_SoSwitch_getTypeId, METH_O, "SoSwitch_getTypeId(SoSwitch self) -> SoType"},
	 { "SoSwitch_initClass", _wrap_SoSwitch_initClass, METH_NOARGS, "SoSwitch_initClass()"},
	 { "new_SoSwitch", _wrap_new_SoSwitch, METH_VARARGS, "\n"
		"SoSwitch()\n"
		"new_SoSwitch(int numchildren) -> SoSwitch\n"
		""},
	 { "SoSwitch_whichChild_set", _wrap_SoSwitch_whichChild_set, METH_VARARGS, "SoSwitch_whichChild_set(SoSwitch self, SoSFInt32 whichChild)"},
	 { "SoSwitch_whichChild_get", _wrap_SoSwitch_whichChild_get, METH_O, "SoSwitch_whichChild_get(SoSwitch self) -> SoSFInt32"},
	 { "SoSwitch_affectsState", _wrap_SoSwitch_affectsState, METH_O, "SoSwitch_affectsState(SoSwitch self) -> SbBool"},
	 { "SoSwitch_doAction", _wrap_SoSwitch_doAction, METH_VARARGS, "SoSwitch_doAction(SoSwitch self, SoAction action)"},
	 { "SoSwitch_callback", _wrap_SoSwitch_callback, METH_VARARGS, "SoSwitch_callback(SoSwitch self, SoCallbackAction action)"},
	 { "SoSwitch_GLRender", _wrap_SoSwitch_GLRender, METH_VARARGS, "SoSwitch_GLRender(SoSwitch self, SoGLRenderAction action)"},
	 { "SoSwitch_pick", _wrap_SoSwitch_pick, METH_VARARGS, "SoSwitch_pick(SoSwitch self, SoPickAction action)"},
	 { "SoSwitch_getBoundingBox", _wrap_SoSwitch_getBoundingBox, METH_VARARGS, "SoSwitch_getBoundingBox(SoSwitch self, SoGetBoundingBoxAction action)"},
	 { "SoSwitch_handleEvent", _wrap_SoSwitch_handleEvent, METH_VARARGS, "SoSwitch_handleEvent(SoSwitch self, SoHandleEventAction action)"},
	 { "SoSwitch_getMatrix", _wrap_SoSwitch_getMatrix, METH_VARARGS, "SoSwitch_getMatrix(SoSwitch self, SoGetMatrixAction action)"},
	 { "SoSwitch_search", _wrap_SoSwitch_search, METH_VARARGS, "SoSwitch_search(SoSwitch self, SoSearchAction action)"},
	 { "SoSwitch_write", _wrap_SoSwitch_write, METH_VARARGS, "SoSwitch_write(SoSwitch self, SoWriteAction action)"},
	 { "SoSwitch_getPrimitiveCount", _wrap_SoSwitch_getPrimitiveCount, METH_VARARGS, "SoSwitch_getPrimitiveCount(SoSwitch self, SoGetPrimitiveCountAction action)"},
	 { "SoSwitch_audioRender", _wrap_SoSwitch_audioRender, METH_VARARGS, "SoSwitch_audioRender(SoSwitch self, SoAudioRenderAction action)"},
	 { "SoSwitch_notify", _wrap_SoSwitch_notify, METH_VARARGS, "SoSwitch_notify(SoSwitch self, SoNotList nl)"},
	 { "SoSwitch_swigregister", SoSwitch_swigregister, METH_O, NULL},
	 { "SoSwitch_swiginit", SoSwitch_swiginit, METH_VARARGS, NULL},
	 { "SoBlinker_getClassTypeId", _wrap_SoBlinker_getClassTypeId, METH_NOARGS, "SoBlinker_getClassTypeId() -> SoType"},
	 { "SoBlinker_getTypeId", _wrap_SoBlinker_getTypeId, METH_O, "SoBlinker_getTypeId(SoBlinker self) -> SoType"},
	 { "SoBlinker_initClass", _wrap_SoBlinker_initClass, METH_NOARGS, "SoBlinker_initClass()"},
	 { "new_SoBlinker", _wrap_new_SoBlinker, METH_NOARGS, "new_SoBlinker() -> SoBlinker"},
	 { "SoBlinker_speed_set", _wrap_SoBlinker_speed_set, METH_VARARGS, "SoBlinker_speed_set(SoBlinker self, SoSFFloat speed)"},
	 { "SoBlinker_speed_get", _wrap_SoBlinker_speed_get, METH_O, "SoBlinker_speed_get(SoBlinker self) -> SoSFFloat"},
	 { "SoBlinker_on_set", _wrap_SoBlinker_on_set, METH_VARARGS, "SoBlinker_on_set(SoBlinker self, SoSFBool on)"},
	 { "SoBlinker_on_get", _wrap_SoBlinker_on_get, METH_O, "SoBlinker_on_get(SoBlinker self) -> SoSFBool"},
	 { "SoBlinker_getBoundingBox", _wrap_SoBlinker_getBoundingBox, METH_VARARGS, "SoBlinker_getBoundingBox(SoBlinker self, SoGetBoundingBoxAction action)"},
	 { "SoBlinker_write", _wrap_SoBlinker_write, METH_VARARGS, "SoBlinker_write(SoBlinker self, SoWriteAction action)"},
	 { "SoBlinker_swigregister", SoBlinker_swigregister, METH_O, NULL},
	 { "SoBlinker_swiginit", SoBlinker_swiginit, METH_VARARGS, NULL},
	 { "SoBumpMapCoordinate_getClassTypeId", _wrap_SoBumpMapCoordinate_getClassTypeId, METH_NOARGS, "SoBumpMapCoordinate_getClassTypeId() -> SoType"},
	 { "SoBumpMapCoordinate_getTypeId", _wrap_SoBumpMapCoordinate_getTypeId, METH_O, "SoBumpMapCoordinate_getTypeId(SoBumpMapCoordinate self) -> SoType"},
	 { "SoBumpMapCoordinate_initClass", _wrap_SoBumpMapCoordinate_initClass, METH_NOARGS, "SoBumpMapCoordinate_initClass()"},
	 { "new_SoBumpMapCoordinate", _wrap_new_SoBumpMapCoordinate, METH_NOARGS, "new_SoBumpMapCoordinate() -> SoBumpMapCoordinate"},
	 { "SoBumpMapCoordinate_point_set", _wrap_SoBumpMapCoordinate_point_set, METH_VARARGS, "SoBumpMapCoordinate_point_set(SoBumpMapCoordinate self, SoMFVec2f point)"},
	 { "SoBumpMapCoordinate_point_get", _wrap_SoBumpMapCoordinate_point_get, METH_O, "SoBumpMapCoordinate_point_get(SoBumpMapCoordinate self) -> SoMFVec2f"},
	 { "SoBumpMapCoordinate_doAction", _wrap_SoBumpMapCoordinate_doAction, METH_VARARGS, "SoBumpMapCoordinate_doAction(SoBumpMapCoordinate self, SoAction action)"},
	 { "SoBumpMapCoordinate_GLRender", _wrap_SoBumpMapCoordinate_GLRender, METH_VARARGS, "SoBumpMapCoordinate_GLRender(SoBumpMapCoordinate self, SoGLRenderAction action)"},
	 { "SoBumpMapCoordinate_callback", _wrap_SoBumpMapCoordinate_callback, METH_VARARGS, "SoBumpMapCoordinate_callback(SoBumpMapCoordinate self, SoCallbackAction action)"},
	 { "SoBumpMapCoordinate_pick", _wrap_SoBumpMapCoordinate_pick, METH_VARARGS, "SoBumpMapCoordinate_pick(SoBumpMapCoordinate self, SoPickAction action)"},
	 { "SoBumpMapCoordinate_swigregister", SoBumpMapCoordinate_swigregister, METH_O, NULL},
	 { "SoBumpMapCoordinate_swiginit", SoBumpMapCoordinate_swiginit, METH_VARARGS, NULL},
	 { "SoBumpMap_getClassTypeId", _wrap_SoBumpMap_getClassTypeId, METH_NOARGS, "SoBumpMap_getClassTypeId() -> SoType"},
	 { "SoBumpMap_getTypeId", _wrap_SoBumpMap_getTypeId, METH_O, "SoBumpMap_getTypeId(SoBumpMap self) -> SoType"},
	 { "SoBumpMap_initClass", _wrap_SoBumpMap_initClass, METH_NOARGS, "SoBumpMap_initClass()"},
	 { "new_SoBumpMap", _wrap_new_SoBumpMap, METH_NOARGS, "new_SoBumpMap() -> SoBumpMap"},
	 { "SoBumpMap_filename_set", _wrap_SoBumpMap_filename_set, METH_VARARGS, "SoBumpMap_filename_set(SoBumpMap self, SoSFString filename)"},
	 { "SoBumpMap_filename_get", _wrap_SoBumpMap_filename_get, METH_O, "SoBumpMap_filename_get(SoBumpMap self) -> SoSFString"},
	 { "SoBumpMap_image_set", _wrap_SoBumpMap_image_set, METH_VARARGS, "SoBumpMap_image_set(SoBumpMap self, SoSFImage image)"},
	 { "SoBumpMap_image_get", _wrap_SoBumpMap_image_get, METH_O, "SoBumpMap_image_get(SoBumpMap self) -> SoSFImage"},
	 { "SoBumpMap_wrapS_set", _wrap_SoBumpMap_wrapS_set, METH_VARARGS, "SoBumpMap_wrapS_set(SoBumpMap self, SoSFEnum wrapS)"},
	 { "SoBumpMap_wrapS_get", _wrap_SoBumpMap_wrapS_get, METH_O, "SoBumpMap_wrapS_get(SoBumpMap self) -> SoSFEnum"},
	 { "SoBumpMap_wrapT_set", _wrap_SoBumpMap_wrapT_set, METH_VARARGS, "SoBumpMap_wrapT_set(SoBumpMap self, SoSFEnum wrapT)"},
	 { "SoBumpMap_wrapT_get", _wrap_SoBumpMap_wrapT_get, METH_O, "SoBumpMap_wrapT_get(SoBumpMap self) -> SoSFEnum"},
	 { "SoBumpMap_doAction", _wrap_SoBumpMap_doAction, METH_VARARGS, "SoBumpMap_doAction(SoBumpMap self, SoAction action)"},
	 { "SoBumpMap_GLRender", _wrap_SoBumpMap_GLRender, METH_VARARGS, "SoBumpMap_GLRender(SoBumpMap self, SoGLRenderAction action)"},
	 { "SoBumpMap_callback", _wrap_SoBumpMap_callback, METH_VARARGS, "SoBumpMap_callback(SoBumpMap self, SoCallbackAction action)"},
	 { "SoBumpMap_rayPick", _wrap_SoBumpMap_rayPick, METH_VARARGS, "SoBumpMap_rayPick(SoBumpMap self, SoRayPickAction action)"},
	 { "SoBumpMap_swigregister", SoBumpMap_swigregister, METH_O, NULL},
	 { "SoBumpMap_swiginit", SoBumpMap_swiginit, METH_VARARGS, NULL},
	 { "SoBumpMapTransform_getClassTypeId", _wrap_SoBumpMapTransform_getClassTypeId, METH_NOARGS, "SoBumpMapTransform_getClassTypeId() -> SoType"},
	 { "SoBumpMapTransform_getTypeId", _wrap_SoBumpMapTransform_getTypeId, METH_O, "SoBumpMapTransform_getTypeId(SoBumpMapTransform self) -> SoType"},
	 { "SoBumpMapTransform_initClass", _wrap_SoBumpMapTransform_initClass, METH_NOARGS, "SoBumpMapTransform_initClass()"},
	 { "new_SoBumpMapTransform", _wrap_new_SoBumpMapTransform, METH_NOARGS, "new_SoBumpMapTransform() -> SoBumpMapTransform"},
	 { "SoBumpMapTransform_translation_set", _wrap_SoBumpMapTransform_translation_set, METH_VARARGS, "SoBumpMapTransform_translation_set(SoBumpMapTransform self, SoSFVec2f translation)"},
	 { "SoBumpMapTransform_translation_get", _wrap_SoBumpMapTransform_translation_get, METH_O, "SoBumpMapTransform_translation_get(SoBumpMapTransform self) -> SoSFVec2f"},
	 { "SoBumpMapTransform_rotation_set", _wrap_SoBumpMapTransform_rotation_set, METH_VARARGS, "SoBumpMapTransform_rotation_set(SoBumpMapTransform self, SoSFFloat rotation)"},
	 { "SoBumpMapTransform_rotation_get", _wrap_SoBumpMapTransform_rotation_get, METH_O, "SoBumpMapTransform_rotation_get(SoBumpMapTransform self) -> SoSFFloat"},
	 { "SoBumpMapTransform_scaleFactor_set", _wrap_SoBumpMapTransform_scaleFactor_set, METH_VARARGS, "SoBumpMapTransform_scaleFactor_set(SoBumpMapTransform self, SoSFVec2f scaleFactor)"},
	 { "SoBumpMapTransform_scaleFactor_get", _wrap_SoBumpMapTransform_scaleFactor_get, METH_O, "SoBumpMapTransform_scaleFactor_get(SoBumpMapTransform self) -> SoSFVec2f"},
	 { "SoBumpMapTransform_center_set", _wrap_SoBumpMapTransform_center_set, METH_VARARGS, "SoBumpMapTransform_center_set(SoBumpMapTransform self, SoSFVec2f center)"},
	 { "SoBumpMapTransform_center_get", _wrap_SoBumpMapTransform_center_get, METH_O, "SoBumpMapTransform_center_get(SoBumpMapTransform self) -> SoSFVec2f"},
	 { "SoBumpMapTransform_doAction", _wrap_SoBumpMapTransform_doAction, METH_VARARGS, "SoBumpMapTransform_doAction(SoBumpMapTransform self, SoAction action)"},
	 { "SoBumpMapTransform_callback", _wrap_SoBumpMapTransform_callback, METH_VARARGS, "SoBumpMapTransform_callback(SoBumpMapTransform self, SoCallbackAction action)"},
	 { "SoBumpMapTransform_GLRender", _wrap_SoBumpMapTransform_GLRender, METH_VARARGS, "SoBumpMapTransform_GLRender(SoBumpMapTransform self, SoGLRenderAction action)"},
	 { "SoBumpMapTransform_getMatrix", _wrap_SoBumpMapTransform_getMatrix, METH_VARARGS, "SoBumpMapTransform_getMatrix(SoBumpMapTransform self, SoGetMatrixAction action)"},
	 { "SoBumpMapTransform_pick", _wrap_SoBumpMapTransform_pick, METH_VARARGS, "SoBumpMapTransform_pick(SoBumpMapTransform self, SoPickAction action)"},
	 { "SoBumpMapTransform_swigregister", SoBumpMapTransform_swigregister, METH_O, NULL},
	 { "SoBumpMapTransform_swiginit", SoBumpMapTransform_swiginit, METH_VARARGS, NULL},
	 { "SoCallback_getClassTypeId", _wrap_SoCallback_getClassTypeId, METH_NOARGS, "SoCallback_getClassTypeId() -> SoType"},
	 { "SoCallback_getTypeId", _wrap_SoCallback_getTypeId, METH_O, "SoCallback_getTypeId(SoCallback self) -> SoType"},
	 { "SoCallback_initClass", _wrap_SoCallback_initClass, METH_NOARGS, "SoCallback_initClass()"},
	 { "new_SoCallback", _wrap_new_SoCallback, METH_NOARGS, "new_SoCallback() -> SoCallback"},
	 { "SoCallback_doAction", _wrap_SoCallback_doAction, METH_VARARGS, "SoCallback_doAction(SoCallback self, SoAction action)"},
	 { "SoCallback_callback", _wrap_SoCallback_callback, METH_VARARGS, "SoCallback_callback(SoCallback self, SoCallbackAction action)"},
	 { "SoCallback_GLRender", _wrap_SoCallback_GLRender, METH_VARARGS, "SoCallback_GLRender(SoCallback self, SoGLRenderAction action)"},
	 { "SoCallback_getBoundingBox", _wrap_SoCallback_getBoundingBox, METH_VARARGS, "SoCallback_getBoundingBox(SoCallback self, SoGetBoundingBoxAction action)"},
	 { "SoCallback_getMatrix", _wrap_SoCallback_getMatrix, METH_VARARGS, "SoCallback_getMatrix(SoCallback self, SoGetMatrixAction action)"},
	 { "SoCallback_handleEvent", _wrap_SoCallback_handleEvent, METH_VARARGS, "SoCallback_handleEvent(SoCallback self, SoHandleEventAction action)"},
	 { "SoCallback_pick", _wrap_SoCallback_pick, METH_VARARGS, "SoCallback_pick(SoCallback self, SoPickAction action)"},
	 { "SoCallback_search", _wrap_SoCallback_search, METH_VARARGS, "SoCallback_search(SoCallback self, SoSearchAction action)"},
	 { "SoCallback_write", _wrap_SoCallback_write, METH_VARARGS, "SoCallback_write(SoCallback self, SoWriteAction action)"},
	 { "SoCallback_getPrimitiveCount", _wrap_SoCallback_getPrimitiveCount, METH_VARARGS, "SoCallback_getPrimitiveCount(SoCallback self, SoGetPrimitiveCountAction action)"},
	 { "SoCallback_setCallback", _wrap_SoCallback_setCallback, METH_VARARGS, "\n"
		"SoCallback_setCallback(SoCallback self, SoCallbackCB * function, void * userdata=None)\n"
		"SoCallback_setCallback(SoCallback self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoCallback_swigregister", SoCallback_swigregister, METH_O, NULL},
	 { "SoCallback_swiginit", SoCallback_swiginit, METH_VARARGS, NULL},
	 { "SoCamera_getClassTypeId", _wrap_SoCamera_getClassTypeId, METH_NOARGS, "SoCamera_getClassTypeId() -> SoType"},
	 { "SoCamera_getTypeId", _wrap_SoCamera_getTypeId, METH_O, "SoCamera_getTypeId(SoCamera self) -> SoType"},
	 { "SoCamera_initClass", _wrap_SoCamera_initClass, METH_NOARGS, "SoCamera_initClass()"},
	 { "SoCamera_viewportMapping_set", _wrap_SoCamera_viewportMapping_set, METH_VARARGS, "SoCamera_viewportMapping_set(SoCamera self, SoSFEnum viewportMapping)"},
	 { "SoCamera_viewportMapping_get", _wrap_SoCamera_viewportMapping_get, METH_O, "SoCamera_viewportMapping_get(SoCamera self) -> SoSFEnum"},
	 { "SoCamera_position_set", _wrap_SoCamera_position_set, METH_VARARGS, "SoCamera_position_set(SoCamera self, SoSFVec3f position)"},
	 { "SoCamera_position_get", _wrap_SoCamera_position_get, METH_O, "SoCamera_position_get(SoCamera self) -> SoSFVec3f"},
	 { "SoCamera_orientation_set", _wrap_SoCamera_orientation_set, METH_VARARGS, "SoCamera_orientation_set(SoCamera self, SoSFRotation orientation)"},
	 { "SoCamera_orientation_get", _wrap_SoCamera_orientation_get, METH_O, "SoCamera_orientation_get(SoCamera self) -> SoSFRotation"},
	 { "SoCamera_aspectRatio_set", _wrap_SoCamera_aspectRatio_set, METH_VARARGS, "SoCamera_aspectRatio_set(SoCamera self, SoSFFloat aspectRatio)"},
	 { "SoCamera_aspectRatio_get", _wrap_SoCamera_aspectRatio_get, METH_O, "SoCamera_aspectRatio_get(SoCamera self) -> SoSFFloat"},
	 { "SoCamera_nearDistance_set", _wrap_SoCamera_nearDistance_set, METH_VARARGS, "SoCamera_nearDistance_set(SoCamera self, SoSFFloat nearDistance)"},
	 { "SoCamera_nearDistance_get", _wrap_SoCamera_nearDistance_get, METH_O, "SoCamera_nearDistance_get(SoCamera self) -> SoSFFloat"},
	 { "SoCamera_farDistance_set", _wrap_SoCamera_farDistance_set, METH_VARARGS, "SoCamera_farDistance_set(SoCamera self, SoSFFloat farDistance)"},
	 { "SoCamera_farDistance_get", _wrap_SoCamera_farDistance_get, METH_O, "SoCamera_farDistance_get(SoCamera self) -> SoSFFloat"},
	 { "SoCamera_focalDistance_set", _wrap_SoCamera_focalDistance_set, METH_VARARGS, "SoCamera_focalDistance_set(SoCamera self, SoSFFloat focalDistance)"},
	 { "SoCamera_focalDistance_get", _wrap_SoCamera_focalDistance_get, METH_O, "SoCamera_focalDistance_get(SoCamera self) -> SoSFFloat"},
	 { "SoCamera_pointAt", _wrap_SoCamera_pointAt, METH_VARARGS, "\n"
		"SoCamera_pointAt(SoCamera self, SbVec3f targetpoint)\n"
		"SoCamera_pointAt(SoCamera self, SbVec3f targetpoint, SbVec3f upvector)\n"
		""},
	 { "SoCamera_scaleHeight", _wrap_SoCamera_scaleHeight, METH_VARARGS, "SoCamera_scaleHeight(SoCamera self, float scalefactor)"},
	 { "SoCamera_getViewVolume", _wrap_SoCamera_getViewVolume, METH_VARARGS, "\n"
		"SoCamera_getViewVolume(SoCamera self, SbViewportRegion vp, SbViewportRegion resultvp, SbMatrix mm=SbMatrix::identity()) -> SbViewVolume\n"
		"SoCamera_getViewVolume(SoCamera self, float useaspectratio=0.0) -> SbViewVolume\n"
		""},
	 { "SoCamera_viewAll", _wrap_SoCamera_viewAll, METH_VARARGS, "\n"
		"SoCamera_viewAll(SoCamera self, SoNode sceneroot, SbViewportRegion vpregion, float const slack=1.0)\n"
		"SoCamera_viewAll(SoCamera self, SoPath path, SbViewportRegion vpregion, float const slack=1.0)\n"
		""},
	 { "SoCamera_getViewportBounds", _wrap_SoCamera_getViewportBounds, METH_VARARGS, "SoCamera_getViewportBounds(SoCamera self, SbViewportRegion region) -> SbViewportRegion"},
	 { "SoCamera_setStereoMode", _wrap_SoCamera_setStereoMode, METH_VARARGS, "SoCamera_setStereoMode(SoCamera self, SoCamera::StereoMode mode)"},
	 { "SoCamera_getStereoMode", _wrap_SoCamera_getStereoMode, METH_O, "SoCamera_getStereoMode(SoCamera self) -> SoCamera::StereoMode"},
	 { "SoCamera_setStereoAdjustment", _wrap_SoCamera_setStereoAdjustment, METH_VARARGS, "SoCamera_setStereoAdjustment(SoCamera self, float adjustment)"},
	 { "SoCamera_getStereoAdjustment", _wrap_SoCamera_getStereoAdjustment, METH_O, "SoCamera_getStereoAdjustment(SoCamera self) -> float"},
	 { "SoCamera_setBalanceAdjustment", _wrap_SoCamera_setBalanceAdjustment, METH_VARARGS, "SoCamera_setBalanceAdjustment(SoCamera self, float adjustment)"},
	 { "SoCamera_getBalanceAdjustment", _wrap_SoCamera_getBalanceAdjustment, METH_O, "SoCamera_getBalanceAdjustment(SoCamera self) -> float"},
	 { "SoCamera_doAction", _wrap_SoCamera_doAction, METH_VARARGS, "SoCamera_doAction(SoCamera self, SoAction action)"},
	 { "SoCamera_callback", _wrap_SoCamera_callback, METH_VARARGS, "SoCamera_callback(SoCamera self, SoCallbackAction action)"},
	 { "SoCamera_GLRender", _wrap_SoCamera_GLRender, METH_VARARGS, "SoCamera_GLRender(SoCamera self, SoGLRenderAction action)"},
	 { "SoCamera_audioRender", _wrap_SoCamera_audioRender, METH_VARARGS, "SoCamera_audioRender(SoCamera self, SoAudioRenderAction action)"},
	 { "SoCamera_getBoundingBox", _wrap_SoCamera_getBoundingBox, METH_VARARGS, "SoCamera_getBoundingBox(SoCamera self, SoGetBoundingBoxAction action)"},
	 { "SoCamera_getMatrix", _wrap_SoCamera_getMatrix, METH_VARARGS, "SoCamera_getMatrix(SoCamera self, SoGetMatrixAction action)"},
	 { "SoCamera_handleEvent", _wrap_SoCamera_handleEvent, METH_VARARGS, "SoCamera_handleEvent(SoCamera self, SoHandleEventAction action)"},
	 { "SoCamera_rayPick", _wrap_SoCamera_rayPick, METH_VARARGS, "SoCamera_rayPick(SoCamera self, SoRayPickAction action)"},
	 { "SoCamera_getPrimitiveCount", _wrap_SoCamera_getPrimitiveCount, METH_VARARGS, "SoCamera_getPrimitiveCount(SoCamera self, SoGetPrimitiveCountAction action)"},
	 { "SoCamera_viewBoundingBox", _wrap_SoCamera_viewBoundingBox, METH_VARARGS, "SoCamera_viewBoundingBox(SoCamera self, SbBox3f box, float aspect, float slack)"},
	 { "SoCamera_swigregister", SoCamera_swigregister, METH_O, NULL},
	 { "SoColorIndex_getClassTypeId", _wrap_SoColorIndex_getClassTypeId, METH_NOARGS, "SoColorIndex_getClassTypeId() -> SoType"},
	 { "SoColorIndex_getTypeId", _wrap_SoColorIndex_getTypeId, METH_O, "SoColorIndex_getTypeId(SoColorIndex self) -> SoType"},
	 { "SoColorIndex_initClass", _wrap_SoColorIndex_initClass, METH_NOARGS, "SoColorIndex_initClass()"},
	 { "new_SoColorIndex", _wrap_new_SoColorIndex, METH_NOARGS, "new_SoColorIndex() -> SoColorIndex"},
	 { "SoColorIndex_index_set", _wrap_SoColorIndex_index_set, METH_VARARGS, "SoColorIndex_index_set(SoColorIndex self, SoMFInt32 index)"},
	 { "SoColorIndex_index_get", _wrap_SoColorIndex_index_get, METH_O, "SoColorIndex_index_get(SoColorIndex self) -> SoMFInt32"},
	 { "SoColorIndex_GLRender", _wrap_SoColorIndex_GLRender, METH_VARARGS, "SoColorIndex_GLRender(SoColorIndex self, SoGLRenderAction action)"},
	 { "SoColorIndex_swigregister", SoColorIndex_swigregister, METH_O, NULL},
	 { "SoColorIndex_swiginit", SoColorIndex_swiginit, METH_VARARGS, NULL},
	 { "SoCone_getClassTypeId", _wrap_SoCone_getClassTypeId, METH_NOARGS, "SoCone_getClassTypeId() -> SoType"},
	 { "SoCone_getTypeId", _wrap_SoCone_getTypeId, METH_O, "SoCone_getTypeId(SoCone self) -> SoType"},
	 { "SoCone_initClass", _wrap_SoCone_initClass, METH_NOARGS, "SoCone_initClass()"},
	 { "new_SoCone", _wrap_new_SoCone, METH_NOARGS, "new_SoCone() -> SoCone"},
	 { "SoCone_parts_set", _wrap_SoCone_parts_set, METH_VARARGS, "SoCone_parts_set(SoCone self, SoSFBitMask parts)"},
	 { "SoCone_parts_get", _wrap_SoCone_parts_get, METH_O, "SoCone_parts_get(SoCone self) -> SoSFBitMask"},
	 { "SoCone_bottomRadius_set", _wrap_SoCone_bottomRadius_set, METH_VARARGS, "SoCone_bottomRadius_set(SoCone self, SoSFFloat bottomRadius)"},
	 { "SoCone_bottomRadius_get", _wrap_SoCone_bottomRadius_get, METH_O, "SoCone_bottomRadius_get(SoCone self) -> SoSFFloat"},
	 { "SoCone_height_set", _wrap_SoCone_height_set, METH_VARARGS, "SoCone_height_set(SoCone self, SoSFFloat height)"},
	 { "SoCone_height_get", _wrap_SoCone_height_get, METH_O, "SoCone_height_get(SoCone self) -> SoSFFloat"},
	 { "SoCone_addPart", _wrap_SoCone_addPart, METH_VARARGS, "SoCone_addPart(SoCone self, SoCone::Part part)"},
	 { "SoCone_removePart", _wrap_SoCone_removePart, METH_VARARGS, "SoCone_removePart(SoCone self, SoCone::Part part)"},
	 { "SoCone_hasPart", _wrap_SoCone_hasPart, METH_VARARGS, "SoCone_hasPart(SoCone self, SoCone::Part part) -> SbBool"},
	 { "SoCone_GLRender", _wrap_SoCone_GLRender, METH_VARARGS, "SoCone_GLRender(SoCone self, SoGLRenderAction action)"},
	 { "SoCone_rayPick", _wrap_SoCone_rayPick, METH_VARARGS, "SoCone_rayPick(SoCone self, SoRayPickAction action)"},
	 { "SoCone_getPrimitiveCount", _wrap_SoCone_getPrimitiveCount, METH_VARARGS, "SoCone_getPrimitiveCount(SoCone self, SoGetPrimitiveCountAction action)"},
	 { "SoCone_swigregister", SoCone_swigregister, METH_O, NULL},
	 { "SoCone_swiginit", SoCone_swiginit, METH_VARARGS, NULL},
	 { "SoCoordinate3_getClassTypeId", _wrap_SoCoordinate3_getClassTypeId, METH_NOARGS, "SoCoordinate3_getClassTypeId() -> SoType"},
	 { "SoCoordinate3_getTypeId", _wrap_SoCoordinate3_getTypeId, METH_O, "SoCoordinate3_getTypeId(SoCoordinate3 self) -> SoType"},
	 { "SoCoordinate3_initClass", _wrap_SoCoordinate3_initClass, METH_NOARGS, "SoCoordinate3_initClass()"},
	 { "new_SoCoordinate3", _wrap_new_SoCoordinate3, METH_NOARGS, "new_SoCoordinate3() -> SoCoordinate3"},
	 { "SoCoordinate3_point_set", _wrap_SoCoordinate3_point_set, METH_VARARGS, "SoCoordinate3_point_set(SoCoordinate3 self, SoMFVec3f point)"},
	 { "SoCoordinate3_point_get", _wrap_SoCoordinate3_point_get, METH_O, "SoCoordinate3_point_get(SoCoordinate3 self) -> SoMFVec3f"},
	 { "SoCoordinate3_doAction", _wrap_SoCoordinate3_doAction, METH_VARARGS, "SoCoordinate3_doAction(SoCoordinate3 self, SoAction action)"},
	 { "SoCoordinate3_GLRender", _wrap_SoCoordinate3_GLRender, METH_VARARGS, "SoCoordinate3_GLRender(SoCoordinate3 self, SoGLRenderAction action)"},
	 { "SoCoordinate3_callback", _wrap_SoCoordinate3_callback, METH_VARARGS, "SoCoordinate3_callback(SoCoordinate3 self, SoCallbackAction action)"},
	 { "SoCoordinate3_getBoundingBox", _wrap_SoCoordinate3_getBoundingBox, METH_VARARGS, "SoCoordinate3_getBoundingBox(SoCoordinate3 self, SoGetBoundingBoxAction action)"},
	 { "SoCoordinate3_pick", _wrap_SoCoordinate3_pick, METH_VARARGS, "SoCoordinate3_pick(SoCoordinate3 self, SoPickAction action)"},
	 { "SoCoordinate3_getPrimitiveCount", _wrap_SoCoordinate3_getPrimitiveCount, METH_VARARGS, "SoCoordinate3_getPrimitiveCount(SoCoordinate3 self, SoGetPrimitiveCountAction action)"},
	 { "SoCoordinate3_swigregister", SoCoordinate3_swigregister, METH_O, NULL},
	 { "SoCoordinate3_swiginit", SoCoordinate3_swiginit, METH_VARARGS, NULL},
	 { "SoCoordinate4_getClassTypeId", _wrap_SoCoordinate4_getClassTypeId, METH_NOARGS, "SoCoordinate4_getClassTypeId() -> SoType"},
	 { "SoCoordinate4_getTypeId", _wrap_SoCoordinate4_getTypeId, METH_O, "SoCoordinate4_getTypeId(SoCoordinate4 self) -> SoType"},
	 { "SoCoordinate4_initClass", _wrap_SoCoordinate4_initClass, METH_NOARGS, "SoCoordinate4_initClass()"},
	 { "new_SoCoordinate4", _wrap_new_SoCoordinate4, METH_NOARGS, "new_SoCoordinate4() -> SoCoordinate4"},
	 { "SoCoordinate4_point_set", _wrap_SoCoordinate4_point_set, METH_VARARGS, "SoCoordinate4_point_set(SoCoordinate4 self, SoMFVec4f point)"},
	 { "SoCoordinate4_point_get", _wrap_SoCoordinate4_point_get, METH_O, "SoCoordinate4_point_get(SoCoordinate4 self) -> SoMFVec4f"},
	 { "SoCoordinate4_doAction", _wrap_SoCoordinate4_doAction, METH_VARARGS, "SoCoordinate4_doAction(SoCoordinate4 self, SoAction action)"},
	 { "SoCoordinate4_GLRender", _wrap_SoCoordinate4_GLRender, METH_VARARGS, "SoCoordinate4_GLRender(SoCoordinate4 self, SoGLRenderAction action)"},
	 { "SoCoordinate4_getBoundingBox", _wrap_SoCoordinate4_getBoundingBox, METH_VARARGS, "SoCoordinate4_getBoundingBox(SoCoordinate4 self, SoGetBoundingBoxAction action)"},
	 { "SoCoordinate4_callback", _wrap_SoCoordinate4_callback, METH_VARARGS, "SoCoordinate4_callback(SoCoordinate4 self, SoCallbackAction action)"},
	 { "SoCoordinate4_pick", _wrap_SoCoordinate4_pick, METH_VARARGS, "SoCoordinate4_pick(SoCoordinate4 self, SoPickAction action)"},
	 { "SoCoordinate4_getPrimitiveCount", _wrap_SoCoordinate4_getPrimitiveCount, METH_VARARGS, "SoCoordinate4_getPrimitiveCount(SoCoordinate4 self, SoGetPrimitiveCountAction action)"},
	 { "SoCoordinate4_swigregister", SoCoordinate4_swigregister, METH_O, NULL},
	 { "SoCoordinate4_swiginit", SoCoordinate4_swiginit, METH_VARARGS, NULL},
	 { "SoCube_getClassTypeId", _wrap_SoCube_getClassTypeId, METH_NOARGS, "SoCube_getClassTypeId() -> SoType"},
	 { "SoCube_getTypeId", _wrap_SoCube_getTypeId, METH_O, "SoCube_getTypeId(SoCube self) -> SoType"},
	 { "SoCube_initClass", _wrap_SoCube_initClass, METH_NOARGS, "SoCube_initClass()"},
	 { "new_SoCube", _wrap_new_SoCube, METH_NOARGS, "new_SoCube() -> SoCube"},
	 { "SoCube_width_set", _wrap_SoCube_width_set, METH_VARARGS, "SoCube_width_set(SoCube self, SoSFFloat width)"},
	 { "SoCube_width_get", _wrap_SoCube_width_get, METH_O, "SoCube_width_get(SoCube self) -> SoSFFloat"},
	 { "SoCube_height_set", _wrap_SoCube_height_set, METH_VARARGS, "SoCube_height_set(SoCube self, SoSFFloat height)"},
	 { "SoCube_height_get", _wrap_SoCube_height_get, METH_O, "SoCube_height_get(SoCube self) -> SoSFFloat"},
	 { "SoCube_depth_set", _wrap_SoCube_depth_set, METH_VARARGS, "SoCube_depth_set(SoCube self, SoSFFloat depth)"},
	 { "SoCube_depth_get", _wrap_SoCube_depth_get, METH_O, "SoCube_depth_get(SoCube self) -> SoSFFloat"},
	 { "SoCube_GLRender", _wrap_SoCube_GLRender, METH_VARARGS, "SoCube_GLRender(SoCube self, SoGLRenderAction action)"},
	 { "SoCube_rayPick", _wrap_SoCube_rayPick, METH_VARARGS, "SoCube_rayPick(SoCube self, SoRayPickAction action)"},
	 { "SoCube_getPrimitiveCount", _wrap_SoCube_getPrimitiveCount, METH_VARARGS, "SoCube_getPrimitiveCount(SoCube self, SoGetPrimitiveCountAction action)"},
	 { "SoCube_swigregister", SoCube_swigregister, METH_O, NULL},
	 { "SoCube_swiginit", SoCube_swiginit, METH_VARARGS, NULL},
	 { "SoCylinder_getClassTypeId", _wrap_SoCylinder_getClassTypeId, METH_NOARGS, "SoCylinder_getClassTypeId() -> SoType"},
	 { "SoCylinder_getTypeId", _wrap_SoCylinder_getTypeId, METH_O, "SoCylinder_getTypeId(SoCylinder self) -> SoType"},
	 { "SoCylinder_initClass", _wrap_SoCylinder_initClass, METH_NOARGS, "SoCylinder_initClass()"},
	 { "new_SoCylinder", _wrap_new_SoCylinder, METH_NOARGS, "new_SoCylinder() -> SoCylinder"},
	 { "SoCylinder_radius_set", _wrap_SoCylinder_radius_set, METH_VARARGS, "SoCylinder_radius_set(SoCylinder self, SoSFFloat radius)"},
	 { "SoCylinder_radius_get", _wrap_SoCylinder_radius_get, METH_O, "SoCylinder_radius_get(SoCylinder self) -> SoSFFloat"},
	 { "SoCylinder_height_set", _wrap_SoCylinder_height_set, METH_VARARGS, "SoCylinder_height_set(SoCylinder self, SoSFFloat height)"},
	 { "SoCylinder_height_get", _wrap_SoCylinder_height_get, METH_O, "SoCylinder_height_get(SoCylinder self) -> SoSFFloat"},
	 { "SoCylinder_parts_set", _wrap_SoCylinder_parts_set, METH_VARARGS, "SoCylinder_parts_set(SoCylinder self, SoSFBitMask parts)"},
	 { "SoCylinder_parts_get", _wrap_SoCylinder_parts_get, METH_O, "SoCylinder_parts_get(SoCylinder self) -> SoSFBitMask"},
	 { "SoCylinder_addPart", _wrap_SoCylinder_addPart, METH_VARARGS, "SoCylinder_addPart(SoCylinder self, SoCylinder::Part part)"},
	 { "SoCylinder_removePart", _wrap_SoCylinder_removePart, METH_VARARGS, "SoCylinder_removePart(SoCylinder self, SoCylinder::Part part)"},
	 { "SoCylinder_hasPart", _wrap_SoCylinder_hasPart, METH_VARARGS, "SoCylinder_hasPart(SoCylinder self, SoCylinder::Part part) -> SbBool"},
	 { "SoCylinder_rayPick", _wrap_SoCylinder_rayPick, METH_VARARGS, "SoCylinder_rayPick(SoCylinder self, SoRayPickAction action)"},
	 { "SoCylinder_getPrimitiveCount", _wrap_SoCylinder_getPrimitiveCount, METH_VARARGS, "SoCylinder_getPrimitiveCount(SoCylinder self, SoGetPrimitiveCountAction action)"},
	 { "SoCylinder_GLRender", _wrap_SoCylinder_GLRender, METH_VARARGS, "SoCylinder_GLRender(SoCylinder self, SoGLRenderAction action)"},
	 { "SoCylinder_swigregister", SoCylinder_swigregister, METH_O, NULL},
	 { "SoCylinder_swiginit", SoCylinder_swiginit, METH_VARARGS, NULL},
	 { "SoEnvironment_getClassTypeId", _wrap_SoEnvironment_getClassTypeId, METH_NOARGS, "SoEnvironment_getClassTypeId() -> SoType"},
	 { "SoEnvironment_getTypeId", _wrap_SoEnvironment_getTypeId, METH_O, "SoEnvironment_getTypeId(SoEnvironment self) -> SoType"},
	 { "SoEnvironment_initClass", _wrap_SoEnvironment_initClass, METH_NOARGS, "SoEnvironment_initClass()"},
	 { "new_SoEnvironment", _wrap_new_SoEnvironment, METH_NOARGS, "new_SoEnvironment() -> SoEnvironment"},
	 { "SoEnvironment_GLRender", _wrap_SoEnvironment_GLRender, METH_VARARGS, "SoEnvironment_GLRender(SoEnvironment self, SoGLRenderAction action)"},
	 { "SoEnvironment_callback", _wrap_SoEnvironment_callback, METH_VARARGS, "SoEnvironment_callback(SoEnvironment self, SoCallbackAction action)"},
	 { "SoEnvironment_ambientIntensity_set", _wrap_SoEnvironment_ambientIntensity_set, METH_VARARGS, "SoEnvironment_ambientIntensity_set(SoEnvironment self, SoSFFloat ambientIntensity)"},
	 { "SoEnvironment_ambientIntensity_get", _wrap_SoEnvironment_ambientIntensity_get, METH_O, "SoEnvironment_ambientIntensity_get(SoEnvironment self) -> SoSFFloat"},
	 { "SoEnvironment_ambientColor_set", _wrap_SoEnvironment_ambientColor_set, METH_VARARGS, "SoEnvironment_ambientColor_set(SoEnvironment self, SoSFColor ambientColor)"},
	 { "SoEnvironment_ambientColor_get", _wrap_SoEnvironment_ambientColor_get, METH_O, "SoEnvironment_ambientColor_get(SoEnvironment self) -> SoSFColor"},
	 { "SoEnvironment_attenuation_set", _wrap_SoEnvironment_attenuation_set, METH_VARARGS, "SoEnvironment_attenuation_set(SoEnvironment self, SoSFVec3f attenuation)"},
	 { "SoEnvironment_attenuation_get", _wrap_SoEnvironment_attenuation_get, METH_O, "SoEnvironment_attenuation_get(SoEnvironment self) -> SoSFVec3f"},
	 { "SoEnvironment_fogType_set", _wrap_SoEnvironment_fogType_set, METH_VARARGS, "SoEnvironment_fogType_set(SoEnvironment self, SoSFEnum fogType)"},
	 { "SoEnvironment_fogType_get", _wrap_SoEnvironment_fogType_get, METH_O, "SoEnvironment_fogType_get(SoEnvironment self) -> SoSFEnum"},
	 { "SoEnvironment_fogColor_set", _wrap_SoEnvironment_fogColor_set, METH_VARARGS, "SoEnvironment_fogColor_set(SoEnvironment self, SoSFColor fogColor)"},
	 { "SoEnvironment_fogColor_get", _wrap_SoEnvironment_fogColor_get, METH_O, "SoEnvironment_fogColor_get(SoEnvironment self) -> SoSFColor"},
	 { "SoEnvironment_fogVisibility_set", _wrap_SoEnvironment_fogVisibility_set, METH_VARARGS, "SoEnvironment_fogVisibility_set(SoEnvironment self, SoSFFloat fogVisibility)"},
	 { "SoEnvironment_fogVisibility_get", _wrap_SoEnvironment_fogVisibility_get, METH_O, "SoEnvironment_fogVisibility_get(SoEnvironment self) -> SoSFFloat"},
	 { "SoEnvironment_swigregister", SoEnvironment_swigregister, METH_O, NULL},
	 { "SoEnvironment_swiginit", SoEnvironment_swiginit, METH_VARARGS, NULL},
	 { "SoEventCallback_getClassTypeId", _wrap_SoEventCallback_getClassTypeId, METH_NOARGS, "SoEventCallback_getClassTypeId() -> SoType"},
	 { "SoEventCallback_getTypeId", _wrap_SoEventCallback_getTypeId, METH_O, "SoEventCallback_getTypeId(SoEventCallback self) -> SoType"},
	 { "SoEventCallback_initClass", _wrap_SoEventCallback_initClass, METH_NOARGS, "SoEventCallback_initClass()"},
	 { "new_SoEventCallback", _wrap_new_SoEventCallback, METH_NOARGS, "new_SoEventCallback() -> SoEventCallback"},
	 { "SoEventCallback_setPath", _wrap_SoEventCallback_setPath, METH_VARARGS, "SoEventCallback_setPath(SoEventCallback self, SoPath path)"},
	 { "SoEventCallback_getPath", _wrap_SoEventCallback_getPath, METH_O, "SoEventCallback_getPath(SoEventCallback self) -> SoPath"},
	 { "SoEventCallback_getAction", _wrap_SoEventCallback_getAction, METH_O, "SoEventCallback_getAction(SoEventCallback self) -> SoHandleEventAction"},
	 { "SoEventCallback_getEvent", _wrap_SoEventCallback_getEvent, METH_O, "SoEventCallback_getEvent(SoEventCallback self) -> SoEvent"},
	 { "SoEventCallback_getPickedPoint", _wrap_SoEventCallback_getPickedPoint, METH_O, "SoEventCallback_getPickedPoint(SoEventCallback self) -> SoPickedPoint"},
	 { "SoEventCallback_setHandled", _wrap_SoEventCallback_setHandled, METH_O, "SoEventCallback_setHandled(SoEventCallback self)"},
	 { "SoEventCallback_isHandled", _wrap_SoEventCallback_isHandled, METH_O, "SoEventCallback_isHandled(SoEventCallback self) -> SbBool"},
	 { "SoEventCallback_grabEvents", _wrap_SoEventCallback_grabEvents, METH_O, "SoEventCallback_grabEvents(SoEventCallback self)"},
	 { "SoEventCallback_releaseEvents", _wrap_SoEventCallback_releaseEvents, METH_O, "SoEventCallback_releaseEvents(SoEventCallback self)"},
	 { "SoEventCallback_addEventCallback", _wrap_SoEventCallback_addEventCallback, METH_VARARGS, "\n"
		"SoEventCallback_addEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)\n"
		"SoEventCallback_addEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc, PyObject * userdata=None) -> PyObject\n"
		""},
	 { "SoEventCallback_removeEventCallback", _wrap_SoEventCallback_removeEventCallback, METH_VARARGS, "\n"
		"SoEventCallback_removeEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)\n"
		"SoEventCallback_removeEventCallback(SoEventCallback self, SoType eventtype, PyObject * tuple)\n"
		""},
	 { "SoEventCallback_swigregister", SoEventCallback_swigregister, METH_O, NULL},
	 { "SoEventCallback_swiginit", SoEventCallback_swiginit, METH_VARARGS, NULL},
	 { "SoSelection_getClassTypeId", _wrap_SoSelection_getClassTypeId, METH_NOARGS, "SoSelection_getClassTypeId() -> SoType"},
	 { "SoSelection_getTypeId", _wrap_SoSelection_getTypeId, METH_O, "SoSelection_getTypeId(SoSelection self) -> SoType"},
	 { "SoSelection_initClass", _wrap_SoSelection_initClass, METH_NOARGS, "SoSelection_initClass()"},
	 { "SoSelection_policy_set", _wrap_SoSelection_policy_set, METH_VARARGS, "SoSelection_policy_set(SoSelection self, SoSFEnum policy)"},
	 { "SoSelection_policy_get", _wrap_SoSelection_policy_get, METH_O, "SoSelection_policy_get(SoSelection self) -> SoSFEnum"},
	 { "new_SoSelection", _wrap_new_SoSelection, METH_VARARGS, "\n"
		"SoSelection()\n"
		"new_SoSelection(int const nChildren) -> SoSelection\n"
		""},
	 { "SoSelection_select", _wrap_SoSelection_select, METH_VARARGS, "\n"
		"SoSelection_select(SoSelection self, SoPath path)\n"
		"SoSelection_select(SoSelection self, SoNode node)\n"
		""},
	 { "SoSelection_deselect", _wrap_SoSelection_deselect, METH_VARARGS, "\n"
		"SoSelection_deselect(SoSelection self, SoPath path)\n"
		"SoSelection_deselect(SoSelection self, int const which)\n"
		"SoSelection_deselect(SoSelection self, SoNode node)\n"
		""},
	 { "SoSelection_toggle", _wrap_SoSelection_toggle, METH_VARARGS, "\n"
		"SoSelection_toggle(SoSelection self, SoPath path)\n"
		"SoSelection_toggle(SoSelection self, SoNode node)\n"
		""},
	 { "SoSelection_isSelected", _wrap_SoSelection_isSelected, METH_VARARGS, "\n"
		"SoSelection_isSelected(SoSelection self, SoPath path) -> SbBool\n"
		"SoSelection_isSelected(SoSelection self, SoNode node) -> SbBool\n"
		""},
	 { "SoSelection_deselectAll", _wrap_SoSelection_deselectAll, METH_O, "SoSelection_deselectAll(SoSelection self)"},
	 { "SoSelection_getNumSelected", _wrap_SoSelection_getNumSelected, METH_O, "SoSelection_getNumSelected(SoSelection self) -> int"},
	 { "SoSelection_getList", _wrap_SoSelection_getList, METH_O, "SoSelection_getList(SoSelection self) -> SoPathList"},
	 { "SoSelection_getPath", _wrap_SoSelection_getPath, METH_VARARGS, "SoSelection_getPath(SoSelection self, int const index) -> SoPath"},
	 { "SoSelection_setPickMatching", _wrap_SoSelection_setPickMatching, METH_VARARGS, "SoSelection_setPickMatching(SoSelection self, SbBool const pickMatching)"},
	 { "SoSelection_isPickMatching", _wrap_SoSelection_isPickMatching, METH_O, "SoSelection_isPickMatching(SoSelection self) -> SbBool"},
	 { "SoSelection_getPickMatching", _wrap_SoSelection_getPickMatching, METH_O, "SoSelection_getPickMatching(SoSelection self) -> SbBool"},
	 { "SoSelection_addSelectionCallback", _wrap_SoSelection_addSelectionCallback, METH_VARARGS, "\n"
		"SoSelection_addSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)\n"
		"SoSelection_addSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_removeSelectionCallback", _wrap_SoSelection_removeSelectionCallback, METH_VARARGS, "\n"
		"SoSelection_removeSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)\n"
		"SoSelection_removeSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_addDeselectionCallback", _wrap_SoSelection_addDeselectionCallback, METH_VARARGS, "\n"
		"SoSelection_addDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)\n"
		"SoSelection_addDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_removeDeselectionCallback", _wrap_SoSelection_removeDeselectionCallback, METH_VARARGS, "\n"
		"SoSelection_removeDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)\n"
		"SoSelection_removeDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_addStartCallback", _wrap_SoSelection_addStartCallback, METH_VARARGS, "\n"
		"SoSelection_addStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_addStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_removeStartCallback", _wrap_SoSelection_removeStartCallback, METH_VARARGS, "\n"
		"SoSelection_removeStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_removeStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_addFinishCallback", _wrap_SoSelection_addFinishCallback, METH_VARARGS, "\n"
		"SoSelection_addFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_addFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_removeFinishCallback", _wrap_SoSelection_removeFinishCallback, METH_VARARGS, "\n"
		"SoSelection_removeFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_removeFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_setPickFilterCallback", _wrap_SoSelection_setPickFilterCallback, METH_VARARGS, "\n"
		"SoSelection_setPickFilterCallback(SoSelection self, SoSelectionPickCB * f, void * userData=None, SbBool const callOnlyIfSelectable=1)\n"
		"SoSelection_setPickFilterCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None, int callOnlyIfSelectable=1)\n"
		""},
	 { "SoSelection_addChangeCallback", _wrap_SoSelection_addChangeCallback, METH_VARARGS, "\n"
		"SoSelection_addChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_addChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_removeChangeCallback", _wrap_SoSelection_removeChangeCallback, METH_VARARGS, "\n"
		"SoSelection_removeChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)\n"
		"SoSelection_removeChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)\n"
		""},
	 { "SoSelection_swigregister", SoSelection_swigregister, METH_O, NULL},
	 { "SoSelection_swiginit", SoSelection_swiginit, METH_VARARGS, NULL},
	 { "SoExtSelection_getClassTypeId", _wrap_SoExtSelection_getClassTypeId, METH_NOARGS, "SoExtSelection_getClassTypeId() -> SoType"},
	 { "SoExtSelection_getTypeId", _wrap_SoExtSelection_getTypeId, METH_O, "SoExtSelection_getTypeId(SoExtSelection self) -> SoType"},
	 { "SoExtSelection_initClass", _wrap_SoExtSelection_initClass, METH_NOARGS, "SoExtSelection_initClass()"},
	 { "new_SoExtSelection", _wrap_new_SoExtSelection, METH_NOARGS, "new_SoExtSelection() -> SoExtSelection"},
	 { "SoExtSelection_lassoType_set", _wrap_SoExtSelection_lassoType_set, METH_VARARGS, "SoExtSelection_lassoType_set(SoExtSelection self, SoSFEnum lassoType)"},
	 { "SoExtSelection_lassoType_get", _wrap_SoExtSelection_lassoType_get, METH_O, "SoExtSelection_lassoType_get(SoExtSelection self) -> SoSFEnum"},
	 { "SoExtSelection_lassoPolicy_set", _wrap_SoExtSelection_lassoPolicy_set, METH_VARARGS, "SoExtSelection_lassoPolicy_set(SoExtSelection self, SoSFEnum lassoPolicy)"},
	 { "SoExtSelection_lassoPolicy_get", _wrap_SoExtSelection_lassoPolicy_get, METH_O, "SoExtSelection_lassoPolicy_get(SoExtSelection self) -> SoSFEnum"},
	 { "SoExtSelection_lassoMode_set", _wrap_SoExtSelection_lassoMode_set, METH_VARARGS, "SoExtSelection_lassoMode_set(SoExtSelection self, SoSFEnum lassoMode)"},
	 { "SoExtSelection_lassoMode_get", _wrap_SoExtSelection_lassoMode_get, METH_O, "SoExtSelection_lassoMode_get(SoExtSelection self) -> SoSFEnum"},
	 { "SoExtSelection_useOverlay", _wrap_SoExtSelection_useOverlay, METH_VARARGS, "SoExtSelection_useOverlay(SoExtSelection self, SbBool overlay=1)"},
	 { "SoExtSelection_isUsingOverlay", _wrap_SoExtSelection_isUsingOverlay, METH_O, "SoExtSelection_isUsingOverlay(SoExtSelection self) -> SbBool"},
	 { "SoExtSelection_getOverlaySceneGraph", _wrap_SoExtSelection_getOverlaySceneGraph, METH_O, "SoExtSelection_getOverlaySceneGraph(SoExtSelection self) -> SoSeparator"},
	 { "SoExtSelection_setOverlayLassoColorIndex", _wrap_SoExtSelection_setOverlayLassoColorIndex, METH_VARARGS, "SoExtSelection_setOverlayLassoColorIndex(SoExtSelection self, int const index)"},
	 { "SoExtSelection_getOverlayLassoColorIndex", _wrap_SoExtSelection_getOverlayLassoColorIndex, METH_O, "SoExtSelection_getOverlayLassoColorIndex(SoExtSelection self) -> int"},
	 { "SoExtSelection_setLassoColor", _wrap_SoExtSelection_setLassoColor, METH_VARARGS, "SoExtSelection_setLassoColor(SoExtSelection self, SbColor color)"},
	 { "SoExtSelection_getLassoColor", _wrap_SoExtSelection_getLassoColor, METH_O, "SoExtSelection_getLassoColor(SoExtSelection self) -> SbColor"},
	 { "SoExtSelection_setLassoWidth", _wrap_SoExtSelection_setLassoWidth, METH_VARARGS, "SoExtSelection_setLassoWidth(SoExtSelection self, float const width)"},
	 { "SoExtSelection_getLassoWidth", _wrap_SoExtSelection_getLassoWidth, METH_O, "SoExtSelection_getLassoWidth(SoExtSelection self) -> float"},
	 { "SoExtSelection_setOverlayLassoPattern", _wrap_SoExtSelection_setOverlayLassoPattern, METH_VARARGS, "SoExtSelection_setOverlayLassoPattern(SoExtSelection self, unsigned short const pattern)"},
	 { "SoExtSelection_getOverlayLassoPattern", _wrap_SoExtSelection_getOverlayLassoPattern, METH_O, "SoExtSelection_getOverlayLassoPattern(SoExtSelection self) -> unsigned short"},
	 { "SoExtSelection_animateOverlayLasso", _wrap_SoExtSelection_animateOverlayLasso, METH_VARARGS, "SoExtSelection_animateOverlayLasso(SoExtSelection self, SbBool const animate=1)"},
	 { "SoExtSelection_isOverlayLassoAnimated", _wrap_SoExtSelection_isOverlayLassoAnimated, METH_O, "SoExtSelection_isOverlayLassoAnimated(SoExtSelection self) -> SbBool"},
	 { "SoExtSelection_handleEvent", _wrap_SoExtSelection_handleEvent, METH_VARARGS, "SoExtSelection_handleEvent(SoExtSelection self, SoHandleEventAction action)"},
	 { "SoExtSelection_GLRenderBelowPath", _wrap_SoExtSelection_GLRenderBelowPath, METH_VARARGS, "SoExtSelection_GLRenderBelowPath(SoExtSelection self, SoGLRenderAction action)"},
	 { "SoExtSelection_select", _wrap_SoExtSelection_select, METH_VARARGS, "\n"
		"SoExtSelection_select(SoExtSelection self, SoNode root, int numcoords, SbVec2f lasso, SbViewportRegion vp, SbBool shiftpolicy)\n"
		"SoExtSelection_select(SoExtSelection self, SoNode root, int numcoords, SbVec3f lasso, SbViewportRegion vp, SbBool shiftkeypolicy)\n"
		""},
	 { "SoExtSelection_getLassoCoordsDC", _wrap_SoExtSelection_getLassoCoordsDC, METH_VARARGS, "SoExtSelection_getLassoCoordsDC(SoExtSelection self, int & numCoords) -> SbVec2s"},
	 { "SoExtSelection_getLassoCoordsWC", _wrap_SoExtSelection_getLassoCoordsWC, METH_VARARGS, "SoExtSelection_getLassoCoordsWC(SoExtSelection self, int & numCoords) -> SbVec3f"},
	 { "SoExtSelection_getSelectionPathList", _wrap_SoExtSelection_getSelectionPathList, METH_O, "SoExtSelection_getSelectionPathList(SoExtSelection self) -> SoPathList"},
	 { "SoExtSelection_setLassoFilterCallback", _wrap_SoExtSelection_setLassoFilterCallback, METH_VARARGS, "SoExtSelection_setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f, void * userdata=None, SbBool const callonlyifselectable=1)"},
	 { "SoExtSelection_setTriangleFilterCallback", _wrap_SoExtSelection_setTriangleFilterCallback, METH_VARARGS, "SoExtSelection_setTriangleFilterCallback(SoExtSelection self, SoExtSelectionTriangleCB * func, void * userdata=None)"},
	 { "SoExtSelection_setLineSegmentFilterCallback", _wrap_SoExtSelection_setLineSegmentFilterCallback, METH_VARARGS, "SoExtSelection_setLineSegmentFilterCallback(SoExtSelection self, SoExtSelectionLineSegmentCB * func, void * userdata=None)"},
	 { "SoExtSelection_setPointFilterCallback", _wrap_SoExtSelection_setPointFilterCallback, METH_VARARGS, "SoExtSelection_setPointFilterCallback(SoExtSelection self, SoExtSelectionPointCB * func, void * userdata=None)"},
	 { "SoExtSelection_wasShiftDown", _wrap_SoExtSelection_wasShiftDown, METH_O, "SoExtSelection_wasShiftDown(SoExtSelection self) -> SbBool"},
	 { "SoExtSelection_swigregister", SoExtSelection_swigregister, METH_O, NULL},
	 { "SoExtSelection_swiginit", SoExtSelection_swiginit, METH_VARARGS, NULL},
	 { "SoVertexProperty_getClassTypeId", _wrap_SoVertexProperty_getClassTypeId, METH_NOARGS, "SoVertexProperty_getClassTypeId() -> SoType"},
	 { "SoVertexProperty_getTypeId", _wrap_SoVertexProperty_getTypeId, METH_O, "SoVertexProperty_getTypeId(SoVertexProperty self) -> SoType"},
	 { "SoVertexProperty_initClass", _wrap_SoVertexProperty_initClass, METH_NOARGS, "SoVertexProperty_initClass()"},
	 { "new_SoVertexProperty", _wrap_new_SoVertexProperty, METH_NOARGS, "new_SoVertexProperty() -> SoVertexProperty"},
	 { "SoVertexProperty_vertex_set", _wrap_SoVertexProperty_vertex_set, METH_VARARGS, "SoVertexProperty_vertex_set(SoVertexProperty self, SoMFVec3f vertex)"},
	 { "SoVertexProperty_vertex_get", _wrap_SoVertexProperty_vertex_get, METH_O, "SoVertexProperty_vertex_get(SoVertexProperty self) -> SoMFVec3f"},
	 { "SoVertexProperty_texCoord_set", _wrap_SoVertexProperty_texCoord_set, METH_VARARGS, "SoVertexProperty_texCoord_set(SoVertexProperty self, SoMFVec2f texCoord)"},
	 { "SoVertexProperty_texCoord_get", _wrap_SoVertexProperty_texCoord_get, METH_O, "SoVertexProperty_texCoord_get(SoVertexProperty self) -> SoMFVec2f"},
	 { "SoVertexProperty_texCoord3_set", _wrap_SoVertexProperty_texCoord3_set, METH_VARARGS, "SoVertexProperty_texCoord3_set(SoVertexProperty self, SoMFVec3f texCoord3)"},
	 { "SoVertexProperty_texCoord3_get", _wrap_SoVertexProperty_texCoord3_get, METH_O, "SoVertexProperty_texCoord3_get(SoVertexProperty self) -> SoMFVec3f"},
	 { "SoVertexProperty_normal_set", _wrap_SoVertexProperty_normal_set, METH_VARARGS, "SoVertexProperty_normal_set(SoVertexProperty self, SoMFVec3f normal)"},
	 { "SoVertexProperty_normal_get", _wrap_SoVertexProperty_normal_get, METH_O, "SoVertexProperty_normal_get(SoVertexProperty self) -> SoMFVec3f"},
	 { "SoVertexProperty_normalBinding_set", _wrap_SoVertexProperty_normalBinding_set, METH_VARARGS, "SoVertexProperty_normalBinding_set(SoVertexProperty self, SoSFEnum normalBinding)"},
	 { "SoVertexProperty_normalBinding_get", _wrap_SoVertexProperty_normalBinding_get, METH_O, "SoVertexProperty_normalBinding_get(SoVertexProperty self) -> SoSFEnum"},
	 { "SoVertexProperty_orderedRGBA_set", _wrap_SoVertexProperty_orderedRGBA_set, METH_VARARGS, "SoVertexProperty_orderedRGBA_set(SoVertexProperty self, SoMFUInt32 orderedRGBA)"},
	 { "SoVertexProperty_orderedRGBA_get", _wrap_SoVertexProperty_orderedRGBA_get, METH_O, "SoVertexProperty_orderedRGBA_get(SoVertexProperty self) -> SoMFUInt32"},
	 { "SoVertexProperty_materialBinding_set", _wrap_SoVertexProperty_materialBinding_set, METH_VARARGS, "SoVertexProperty_materialBinding_set(SoVertexProperty self, SoSFEnum materialBinding)"},
	 { "SoVertexProperty_materialBinding_get", _wrap_SoVertexProperty_materialBinding_get, METH_O, "SoVertexProperty_materialBinding_get(SoVertexProperty self) -> SoSFEnum"},
	 { "SoVertexProperty_textureUnit_set", _wrap_SoVertexProperty_textureUnit_set, METH_VARARGS, "SoVertexProperty_textureUnit_set(SoVertexProperty self, SoMFInt32 textureUnit)"},
	 { "SoVertexProperty_textureUnit_get", _wrap_SoVertexProperty_textureUnit_get, METH_O, "SoVertexProperty_textureUnit_get(SoVertexProperty self) -> SoMFInt32"},
	 { "SoVertexProperty_doAction", _wrap_SoVertexProperty_doAction, METH_VARARGS, "SoVertexProperty_doAction(SoVertexProperty self, SoAction action)"},
	 { "SoVertexProperty_GLRender", _wrap_SoVertexProperty_GLRender, METH_VARARGS, "SoVertexProperty_GLRender(SoVertexProperty self, SoGLRenderAction action)"},
	 { "SoVertexProperty_getBoundingBox", _wrap_SoVertexProperty_getBoundingBox, METH_VARARGS, "SoVertexProperty_getBoundingBox(SoVertexProperty self, SoGetBoundingBoxAction action)"},
	 { "SoVertexProperty_callback", _wrap_SoVertexProperty_callback, METH_VARARGS, "SoVertexProperty_callback(SoVertexProperty self, SoCallbackAction action)"},
	 { "SoVertexProperty_pick", _wrap_SoVertexProperty_pick, METH_VARARGS, "SoVertexProperty_pick(SoVertexProperty self, SoPickAction action)"},
	 { "SoVertexProperty_getPrimitiveCount", _wrap_SoVertexProperty_getPrimitiveCount, METH_VARARGS, "SoVertexProperty_getPrimitiveCount(SoVertexProperty self, SoGetPrimitiveCountAction action)"},
	 { "SoVertexProperty_swigregister", SoVertexProperty_swigregister, METH_O, NULL},
	 { "SoVertexProperty_swiginit", SoVertexProperty_swiginit, METH_VARARGS, NULL},
	 { "SoVertexShape_getClassTypeId", _wrap_SoVertexShape_getClassTypeId, METH_NOARGS, "SoVertexShape_getClassTypeId() -> SoType"},
	 { "SoVertexShape_getTypeId", _wrap_SoVertexShape_getTypeId, METH_O, "SoVertexShape_getTypeId(SoVertexShape self) -> SoType"},
	 { "SoVertexShape_initClass", _wrap_SoVertexShape_initClass, METH_NOARGS, "SoVertexShape_initClass()"},
	 { "SoVertexShape_vertexProperty_set", _wrap_SoVertexShape_vertexProperty_set, METH_VARARGS, "SoVertexShape_vertexProperty_set(SoVertexShape self, SoSFNode vertexProperty)"},
	 { "SoVertexShape_vertexProperty_get", _wrap_SoVertexShape_vertexProperty_get, METH_O, "SoVertexShape_vertexProperty_get(SoVertexShape self) -> SoSFNode"},
	 { "SoVertexShape_notify", _wrap_SoVertexShape_notify, METH_VARARGS, "SoVertexShape_notify(SoVertexShape self, SoNotList nl)"},
	 { "SoVertexShape_generateDefaultNormals", _wrap_SoVertexShape_generateDefaultNormals, METH_VARARGS, "\n"
		"SoVertexShape_generateDefaultNormals(SoVertexShape self, SoState state, SoNormalBundle bundle) -> SbBool\n"
		"SoVertexShape_generateDefaultNormals(SoVertexShape self, SoState state, SoNormalCache cache) -> SbBool\n"
		""},
	 { "SoVertexShape_write", _wrap_SoVertexShape_write, METH_VARARGS, "SoVertexShape_write(SoVertexShape self, SoWriteAction action)"},
	 { "SoVertexShape_swigregister", SoVertexShape_swigregister, METH_O, NULL},
	 { "SoNonIndexedShape_getClassTypeId", _wrap_SoNonIndexedShape_getClassTypeId, METH_NOARGS, "SoNonIndexedShape_getClassTypeId() -> SoType"},
	 { "SoNonIndexedShape_getTypeId", _wrap_SoNonIndexedShape_getTypeId, METH_O, "SoNonIndexedShape_getTypeId(SoNonIndexedShape self) -> SoType"},
	 { "SoNonIndexedShape_initClass", _wrap_SoNonIndexedShape_initClass, METH_NOARGS, "SoNonIndexedShape_initClass()"},
	 { "SoNonIndexedShape_startIndex_set", _wrap_SoNonIndexedShape_startIndex_set, METH_VARARGS, "SoNonIndexedShape_startIndex_set(SoNonIndexedShape self, SoSFInt32 startIndex)"},
	 { "SoNonIndexedShape_startIndex_get", _wrap_SoNonIndexedShape_startIndex_get, METH_O, "SoNonIndexedShape_startIndex_get(SoNonIndexedShape self) -> SoSFInt32"},
	 { "SoNonIndexedShape_swigregister", SoNonIndexedShape_swigregister, METH_O, NULL},
	 { "SoFaceSet_getClassTypeId", _wrap_SoFaceSet_getClassTypeId, METH_NOARGS, "SoFaceSet_getClassTypeId() -> SoType"},
	 { "SoFaceSet_getTypeId", _wrap_SoFaceSet_getTypeId, METH_O, "SoFaceSet_getTypeId(SoFaceSet self) -> SoType"},
	 { "SoFaceSet_initClass", _wrap_SoFaceSet_initClass, METH_NOARGS, "SoFaceSet_initClass()"},
	 { "new_SoFaceSet", _wrap_new_SoFaceSet, METH_NOARGS, "new_SoFaceSet() -> SoFaceSet"},
	 { "SoFaceSet_numVertices_set", _wrap_SoFaceSet_numVertices_set, METH_VARARGS, "SoFaceSet_numVertices_set(SoFaceSet self, SoMFInt32 numVertices)"},
	 { "SoFaceSet_numVertices_get", _wrap_SoFaceSet_numVertices_get, METH_O, "SoFaceSet_numVertices_get(SoFaceSet self) -> SoMFInt32"},
	 { "SoFaceSet_GLRender", _wrap_SoFaceSet_GLRender, METH_VARARGS, "SoFaceSet_GLRender(SoFaceSet self, SoGLRenderAction action)"},
	 { "SoFaceSet_generateDefaultNormals", _wrap_SoFaceSet_generateDefaultNormals, METH_VARARGS, "SoFaceSet_generateDefaultNormals(SoFaceSet self, SoState state, SoNormalBundle nb) -> SbBool"},
	 { "SoFaceSet_getPrimitiveCount", _wrap_SoFaceSet_getPrimitiveCount, METH_VARARGS, "SoFaceSet_getPrimitiveCount(SoFaceSet self, SoGetPrimitiveCountAction action)"},
	 { "SoFaceSet_swigregister", SoFaceSet_swigregister, METH_O, NULL},
	 { "SoFaceSet_swiginit", SoFaceSet_swiginit, METH_VARARGS, NULL},
	 { "SoFile_getClassTypeId", _wrap_SoFile_getClassTypeId, METH_NOARGS, "SoFile_getClassTypeId() -> SoType"},
	 { "SoFile_getTypeId", _wrap_SoFile_getTypeId, METH_O, "SoFile_getTypeId(SoFile self) -> SoType"},
	 { "SoFile_initClass", _wrap_SoFile_initClass, METH_NOARGS, "SoFile_initClass()"},
	 { "new_SoFile", _wrap_new_SoFile, METH_NOARGS, "new_SoFile() -> SoFile"},
	 { "SoFile_name_set", _wrap_SoFile_name_set, METH_VARARGS, "SoFile_name_set(SoFile self, SoSFString name)"},
	 { "SoFile_name_get", _wrap_SoFile_name_get, METH_O, "SoFile_name_get(SoFile self) -> SoSFString"},
	 { "SoFile_doAction", _wrap_SoFile_doAction, METH_VARARGS, "SoFile_doAction(SoFile self, SoAction action)"},
	 { "SoFile_callback", _wrap_SoFile_callback, METH_VARARGS, "SoFile_callback(SoFile self, SoCallbackAction action)"},
	 { "SoFile_GLRender", _wrap_SoFile_GLRender, METH_VARARGS, "SoFile_GLRender(SoFile self, SoGLRenderAction action)"},
	 { "SoFile_getBoundingBox", _wrap_SoFile_getBoundingBox, METH_VARARGS, "SoFile_getBoundingBox(SoFile self, SoGetBoundingBoxAction action)"},
	 { "SoFile_getMatrix", _wrap_SoFile_getMatrix, METH_VARARGS, "SoFile_getMatrix(SoFile self, SoGetMatrixAction action)"},
	 { "SoFile_handleEvent", _wrap_SoFile_handleEvent, METH_VARARGS, "SoFile_handleEvent(SoFile self, SoHandleEventAction action)"},
	 { "SoFile_pick", _wrap_SoFile_pick, METH_VARARGS, "SoFile_pick(SoFile self, SoPickAction action)"},
	 { "SoFile_getPrimitiveCount", _wrap_SoFile_getPrimitiveCount, METH_VARARGS, "SoFile_getPrimitiveCount(SoFile self, SoGetPrimitiveCountAction action)"},
	 { "SoFile_audioRender", _wrap_SoFile_audioRender, METH_VARARGS, "SoFile_audioRender(SoFile self, SoAudioRenderAction action)"},
	 { "SoFile_search", _wrap_SoFile_search, METH_VARARGS, "SoFile_search(SoFile self, SoSearchAction action)"},
	 { "SoFile_copyChildren", _wrap_SoFile_copyChildren, METH_O, "SoFile_copyChildren(SoFile self) -> SoGroup"},
	 { "SoFile_getChildren", _wrap_SoFile_getChildren, METH_O, "SoFile_getChildren(SoFile self) -> SoChildList"},
	 { "SoFile_copyContents", _wrap_SoFile_copyContents, METH_VARARGS, "SoFile_copyContents(SoFile self, SoFieldContainer srcFrom, SbBool copyconnections)"},
	 { "SoFile_getFullName", _wrap_SoFile_getFullName, METH_O, "SoFile_getFullName(SoFile self) -> SbString"},
	 { "SoFile_setSearchOK", _wrap_SoFile_setSearchOK, METH_O, "SoFile_setSearchOK(SbBool dosearch)"},
	 { "SoFile_getSearchOK", _wrap_SoFile_getSearchOK, METH_NOARGS, "SoFile_getSearchOK() -> SbBool"},
	 { "SoFile_swigregister", SoFile_swigregister, METH_O, NULL},
	 { "SoFile_swiginit", SoFile_swiginit, METH_VARARGS, NULL},
	 { "SoFont_getClassTypeId", _wrap_SoFont_getClassTypeId, METH_NOARGS, "SoFont_getClassTypeId() -> SoType"},
	 { "SoFont_getTypeId", _wrap_SoFont_getTypeId, METH_O, "SoFont_getTypeId(SoFont self) -> SoType"},
	 { "SoFont_initClass", _wrap_SoFont_initClass, METH_NOARGS, "SoFont_initClass()"},
	 { "new_SoFont", _wrap_new_SoFont, METH_NOARGS, "new_SoFont() -> SoFont"},
	 { "SoFont_name_set", _wrap_SoFont_name_set, METH_VARARGS, "SoFont_name_set(SoFont self, SoSFName name)"},
	 { "SoFont_name_get", _wrap_SoFont_name_get, METH_O, "SoFont_name_get(SoFont self) -> SoSFName"},
	 { "SoFont_size_set", _wrap_SoFont_size_set, METH_VARARGS, "SoFont_size_set(SoFont self, SoSFFloat size)"},
	 { "SoFont_size_get", _wrap_SoFont_size_get, METH_O, "SoFont_size_get(SoFont self) -> SoSFFloat"},
	 { "SoFont_doAction", _wrap_SoFont_doAction, METH_VARARGS, "SoFont_doAction(SoFont self, SoAction action)"},
	 { "SoFont_getBoundingBox", _wrap_SoFont_getBoundingBox, METH_VARARGS, "SoFont_getBoundingBox(SoFont self, SoGetBoundingBoxAction action)"},
	 { "SoFont_GLRender", _wrap_SoFont_GLRender, METH_VARARGS, "SoFont_GLRender(SoFont self, SoGLRenderAction action)"},
	 { "SoFont_callback", _wrap_SoFont_callback, METH_VARARGS, "SoFont_callback(SoFont self, SoCallbackAction action)"},
	 { "SoFont_pick", _wrap_SoFont_pick, METH_VARARGS, "SoFont_pick(SoFont self, SoPickAction action)"},
	 { "SoFont_getPrimitiveCount", _wrap_SoFont_getPrimitiveCount, METH_VARARGS, "SoFont_getPrimitiveCount(SoFont self, SoGetPrimitiveCountAction action)"},
	 { "SoFont_swigregister", SoFont_swigregister, METH_O, NULL},
	 { "SoFont_swiginit", SoFont_swiginit, METH_VARARGS, NULL},
	 { "SoFontStyle_getClassTypeId", _wrap_SoFontStyle_getClassTypeId, METH_NOARGS, "SoFontStyle_getClassTypeId() -> SoType"},
	 { "SoFontStyle_getTypeId", _wrap_SoFontStyle_getTypeId, METH_O, "SoFontStyle_getTypeId(SoFontStyle self) -> SoType"},
	 { "SoFontStyle_initClass", _wrap_SoFontStyle_initClass, METH_NOARGS, "SoFontStyle_initClass()"},
	 { "new_SoFontStyle", _wrap_new_SoFontStyle, METH_NOARGS, "new_SoFontStyle() -> SoFontStyle"},
	 { "SoFontStyle_family_set", _wrap_SoFontStyle_family_set, METH_VARARGS, "SoFontStyle_family_set(SoFontStyle self, SoSFEnum family)"},
	 { "SoFontStyle_family_get", _wrap_SoFontStyle_family_get, METH_O, "SoFontStyle_family_get(SoFontStyle self) -> SoSFEnum"},
	 { "SoFontStyle_style_set", _wrap_SoFontStyle_style_set, METH_VARARGS, "SoFontStyle_style_set(SoFontStyle self, SoSFBitMask style)"},
	 { "SoFontStyle_style_get", _wrap_SoFontStyle_style_get, METH_O, "SoFontStyle_style_get(SoFontStyle self) -> SoSFBitMask"},
	 { "SoFontStyle_getFontName", _wrap_SoFontStyle_getFontName, METH_O, "SoFontStyle_getFontName(SoFontStyle self) -> SbString"},
	 { "SoFontStyle_doAction", _wrap_SoFontStyle_doAction, METH_VARARGS, "SoFontStyle_doAction(SoFontStyle self, SoAction action)"},
	 { "SoFontStyle_getBoundingBox", _wrap_SoFontStyle_getBoundingBox, METH_VARARGS, "SoFontStyle_getBoundingBox(SoFontStyle self, SoGetBoundingBoxAction action)"},
	 { "SoFontStyle_GLRender", _wrap_SoFontStyle_GLRender, METH_VARARGS, "SoFontStyle_GLRender(SoFontStyle self, SoGLRenderAction action)"},
	 { "SoFontStyle_callback", _wrap_SoFontStyle_callback, METH_VARARGS, "SoFontStyle_callback(SoFontStyle self, SoCallbackAction action)"},
	 { "SoFontStyle_pick", _wrap_SoFontStyle_pick, METH_VARARGS, "SoFontStyle_pick(SoFontStyle self, SoPickAction action)"},
	 { "SoFontStyle_getPrimitiveCount", _wrap_SoFontStyle_getPrimitiveCount, METH_VARARGS, "SoFontStyle_getPrimitiveCount(SoFontStyle self, SoGetPrimitiveCountAction action)"},
	 { "SoFontStyle_swigregister", SoFontStyle_swigregister, METH_O, NULL},
	 { "SoFontStyle_swiginit", SoFontStyle_swiginit, METH_VARARGS, NULL},
	 { "SoGeoCoordinate_getClassTypeId", _wrap_SoGeoCoordinate_getClassTypeId, METH_NOARGS, "SoGeoCoordinate_getClassTypeId() -> SoType"},
	 { "SoGeoCoordinate_getTypeId", _wrap_SoGeoCoordinate_getTypeId, METH_O, "SoGeoCoordinate_getTypeId(SoGeoCoordinate self) -> SoType"},
	 { "SoGeoCoordinate_initClass", _wrap_SoGeoCoordinate_initClass, METH_NOARGS, "SoGeoCoordinate_initClass()"},
	 { "new_SoGeoCoordinate", _wrap_new_SoGeoCoordinate, METH_NOARGS, "new_SoGeoCoordinate() -> SoGeoCoordinate"},
	 { "SoGeoCoordinate_point_set", _wrap_SoGeoCoordinate_point_set, METH_VARARGS, "SoGeoCoordinate_point_set(SoGeoCoordinate self, SoMFVec3d point)"},
	 { "SoGeoCoordinate_point_get", _wrap_SoGeoCoordinate_point_get, METH_O, "SoGeoCoordinate_point_get(SoGeoCoordinate self) -> SoMFVec3d"},
	 { "SoGeoCoordinate_geoSystem_set", _wrap_SoGeoCoordinate_geoSystem_set, METH_VARARGS, "SoGeoCoordinate_geoSystem_set(SoGeoCoordinate self, SoMFString geoSystem)"},
	 { "SoGeoCoordinate_geoSystem_get", _wrap_SoGeoCoordinate_geoSystem_get, METH_O, "SoGeoCoordinate_geoSystem_get(SoGeoCoordinate self) -> SoMFString"},
	 { "SoGeoCoordinate_doAction", _wrap_SoGeoCoordinate_doAction, METH_VARARGS, "SoGeoCoordinate_doAction(SoGeoCoordinate self, SoAction action)"},
	 { "SoGeoCoordinate_callback", _wrap_SoGeoCoordinate_callback, METH_VARARGS, "SoGeoCoordinate_callback(SoGeoCoordinate self, SoCallbackAction action)"},
	 { "SoGeoCoordinate_GLRender", _wrap_SoGeoCoordinate_GLRender, METH_VARARGS, "SoGeoCoordinate_GLRender(SoGeoCoordinate self, SoGLRenderAction action)"},
	 { "SoGeoCoordinate_getBoundingBox", _wrap_SoGeoCoordinate_getBoundingBox, METH_VARARGS, "SoGeoCoordinate_getBoundingBox(SoGeoCoordinate self, SoGetBoundingBoxAction action)"},
	 { "SoGeoCoordinate_pick", _wrap_SoGeoCoordinate_pick, METH_VARARGS, "SoGeoCoordinate_pick(SoGeoCoordinate self, SoPickAction action)"},
	 { "SoGeoCoordinate_getPrimitiveCount", _wrap_SoGeoCoordinate_getPrimitiveCount, METH_VARARGS, "SoGeoCoordinate_getPrimitiveCount(SoGeoCoordinate self, SoGetPrimitiveCountAction action)"},
	 { "SoGeoCoordinate_swigregister", SoGeoCoordinate_swigregister, METH_O, NULL},
	 { "SoGeoCoordinate_swiginit", SoGeoCoordinate_swiginit, METH_VARARGS, NULL},
	 { "SoGeoLocation_getClassTypeId", _wrap_SoGeoLocation_getClassTypeId, METH_NOARGS, "SoGeoLocation_getClassTypeId() -> SoType"},
	 { "SoGeoLocation_getTypeId", _wrap_SoGeoLocation_getTypeId, METH_O, "SoGeoLocation_getTypeId(SoGeoLocation self) -> SoType"},
	 { "SoGeoLocation_initClass", _wrap_SoGeoLocation_initClass, METH_NOARGS, "SoGeoLocation_initClass()"},
	 { "new_SoGeoLocation", _wrap_new_SoGeoLocation, METH_NOARGS, "new_SoGeoLocation() -> SoGeoLocation"},
	 { "SoGeoLocation_geoCoords_set", _wrap_SoGeoLocation_geoCoords_set, METH_VARARGS, "SoGeoLocation_geoCoords_set(SoGeoLocation self, SoSFVec3d geoCoords)"},
	 { "SoGeoLocation_geoCoords_get", _wrap_SoGeoLocation_geoCoords_get, METH_O, "SoGeoLocation_geoCoords_get(SoGeoLocation self) -> SoSFVec3d"},
	 { "SoGeoLocation_geoSystem_set", _wrap_SoGeoLocation_geoSystem_set, METH_VARARGS, "SoGeoLocation_geoSystem_set(SoGeoLocation self, SoMFString geoSystem)"},
	 { "SoGeoLocation_geoSystem_get", _wrap_SoGeoLocation_geoSystem_get, METH_O, "SoGeoLocation_geoSystem_get(SoGeoLocation self) -> SoMFString"},
	 { "SoGeoLocation_doAction", _wrap_SoGeoLocation_doAction, METH_VARARGS, "SoGeoLocation_doAction(SoGeoLocation self, SoAction action)"},
	 { "SoGeoLocation_callback", _wrap_SoGeoLocation_callback, METH_VARARGS, "SoGeoLocation_callback(SoGeoLocation self, SoCallbackAction action)"},
	 { "SoGeoLocation_GLRender", _wrap_SoGeoLocation_GLRender, METH_VARARGS, "SoGeoLocation_GLRender(SoGeoLocation self, SoGLRenderAction action)"},
	 { "SoGeoLocation_getBoundingBox", _wrap_SoGeoLocation_getBoundingBox, METH_VARARGS, "SoGeoLocation_getBoundingBox(SoGeoLocation self, SoGetBoundingBoxAction action)"},
	 { "SoGeoLocation_getMatrix", _wrap_SoGeoLocation_getMatrix, METH_VARARGS, "SoGeoLocation_getMatrix(SoGeoLocation self, SoGetMatrixAction action)"},
	 { "SoGeoLocation_pick", _wrap_SoGeoLocation_pick, METH_VARARGS, "SoGeoLocation_pick(SoGeoLocation self, SoPickAction action)"},
	 { "SoGeoLocation_getPrimitiveCount", _wrap_SoGeoLocation_getPrimitiveCount, METH_VARARGS, "SoGeoLocation_getPrimitiveCount(SoGeoLocation self, SoGetPrimitiveCountAction action)"},
	 { "SoGeoLocation_swigregister", SoGeoLocation_swigregister, METH_O, NULL},
	 { "SoGeoLocation_swiginit", SoGeoLocation_swiginit, METH_VARARGS, NULL},
	 { "SoGeoOrigin_getClassTypeId", _wrap_SoGeoOrigin_getClassTypeId, METH_NOARGS, "SoGeoOrigin_getClassTypeId() -> SoType"},
	 { "SoGeoOrigin_getTypeId", _wrap_SoGeoOrigin_getTypeId, METH_O, "SoGeoOrigin_getTypeId(SoGeoOrigin self) -> SoType"},
	 { "SoGeoOrigin_initClass", _wrap_SoGeoOrigin_initClass, METH_NOARGS, "SoGeoOrigin_initClass()"},
	 { "new_SoGeoOrigin", _wrap_new_SoGeoOrigin, METH_NOARGS, "new_SoGeoOrigin() -> SoGeoOrigin"},
	 { "SoGeoOrigin_geoCoords_set", _wrap_SoGeoOrigin_geoCoords_set, METH_VARARGS, "SoGeoOrigin_geoCoords_set(SoGeoOrigin self, SoSFVec3d geoCoords)"},
	 { "SoGeoOrigin_geoCoords_get", _wrap_SoGeoOrigin_geoCoords_get, METH_O, "SoGeoOrigin_geoCoords_get(SoGeoOrigin self) -> SoSFVec3d"},
	 { "SoGeoOrigin_geoSystem_set", _wrap_SoGeoOrigin_geoSystem_set, METH_VARARGS, "SoGeoOrigin_geoSystem_set(SoGeoOrigin self, SoMFString geoSystem)"},
	 { "SoGeoOrigin_geoSystem_get", _wrap_SoGeoOrigin_geoSystem_get, METH_O, "SoGeoOrigin_geoSystem_get(SoGeoOrigin self) -> SoMFString"},
	 { "SoGeoOrigin_doAction", _wrap_SoGeoOrigin_doAction, METH_VARARGS, "SoGeoOrigin_doAction(SoGeoOrigin self, SoAction action)"},
	 { "SoGeoOrigin_callback", _wrap_SoGeoOrigin_callback, METH_VARARGS, "SoGeoOrigin_callback(SoGeoOrigin self, SoCallbackAction action)"},
	 { "SoGeoOrigin_GLRender", _wrap_SoGeoOrigin_GLRender, METH_VARARGS, "SoGeoOrigin_GLRender(SoGeoOrigin self, SoGLRenderAction action)"},
	 { "SoGeoOrigin_getBoundingBox", _wrap_SoGeoOrigin_getBoundingBox, METH_VARARGS, "SoGeoOrigin_getBoundingBox(SoGeoOrigin self, SoGetBoundingBoxAction action)"},
	 { "SoGeoOrigin_getMatrix", _wrap_SoGeoOrigin_getMatrix, METH_VARARGS, "SoGeoOrigin_getMatrix(SoGeoOrigin self, SoGetMatrixAction action)"},
	 { "SoGeoOrigin_pick", _wrap_SoGeoOrigin_pick, METH_VARARGS, "SoGeoOrigin_pick(SoGeoOrigin self, SoPickAction action)"},
	 { "SoGeoOrigin_getPrimitiveCount", _wrap_SoGeoOrigin_getPrimitiveCount, METH_VARARGS, "SoGeoOrigin_getPrimitiveCount(SoGeoOrigin self, SoGetPrimitiveCountAction action)"},
	 { "SoGeoOrigin_swigregister", SoGeoOrigin_swigregister, METH_O, NULL},
	 { "SoGeoOrigin_swiginit", SoGeoOrigin_swiginit, METH_VARARGS, NULL},
	 { "SoGeoSeparator_getClassTypeId", _wrap_SoGeoSeparator_getClassTypeId, METH_NOARGS, "SoGeoSeparator_getClassTypeId() -> SoType"},
	 { "SoGeoSeparator_getTypeId", _wrap_SoGeoSeparator_getTypeId, METH_O, "SoGeoSeparator_getTypeId(SoGeoSeparator self) -> SoType"},
	 { "SoGeoSeparator_initClass", _wrap_SoGeoSeparator_initClass, METH_NOARGS, "SoGeoSeparator_initClass()"},
	 { "new_SoGeoSeparator", _wrap_new_SoGeoSeparator, METH_NOARGS, "new_SoGeoSeparator() -> SoGeoSeparator"},
	 { "SoGeoSeparator_geoCoords_set", _wrap_SoGeoSeparator_geoCoords_set, METH_VARARGS, "SoGeoSeparator_geoCoords_set(SoGeoSeparator self, SoSFVec3d geoCoords)"},
	 { "SoGeoSeparator_geoCoords_get", _wrap_SoGeoSeparator_geoCoords_get, METH_O, "SoGeoSeparator_geoCoords_get(SoGeoSeparator self) -> SoSFVec3d"},
	 { "SoGeoSeparator_geoSystem_set", _wrap_SoGeoSeparator_geoSystem_set, METH_VARARGS, "SoGeoSeparator_geoSystem_set(SoGeoSeparator self, SoMFString geoSystem)"},
	 { "SoGeoSeparator_geoSystem_get", _wrap_SoGeoSeparator_geoSystem_get, METH_O, "SoGeoSeparator_geoSystem_get(SoGeoSeparator self) -> SoMFString"},
	 { "SoGeoSeparator_callback", _wrap_SoGeoSeparator_callback, METH_VARARGS, "SoGeoSeparator_callback(SoGeoSeparator self, SoCallbackAction action)"},
	 { "SoGeoSeparator_GLRenderBelowPath", _wrap_SoGeoSeparator_GLRenderBelowPath, METH_VARARGS, "SoGeoSeparator_GLRenderBelowPath(SoGeoSeparator self, SoGLRenderAction action)"},
	 { "SoGeoSeparator_GLRenderInPath", _wrap_SoGeoSeparator_GLRenderInPath, METH_VARARGS, "SoGeoSeparator_GLRenderInPath(SoGeoSeparator self, SoGLRenderAction action)"},
	 { "SoGeoSeparator_getBoundingBox", _wrap_SoGeoSeparator_getBoundingBox, METH_VARARGS, "SoGeoSeparator_getBoundingBox(SoGeoSeparator self, SoGetBoundingBoxAction action)"},
	 { "SoGeoSeparator_getMatrix", _wrap_SoGeoSeparator_getMatrix, METH_VARARGS, "SoGeoSeparator_getMatrix(SoGeoSeparator self, SoGetMatrixAction action)"},
	 { "SoGeoSeparator_rayPick", _wrap_SoGeoSeparator_rayPick, METH_VARARGS, "SoGeoSeparator_rayPick(SoGeoSeparator self, SoRayPickAction action)"},
	 { "SoGeoSeparator_getPrimitiveCount", _wrap_SoGeoSeparator_getPrimitiveCount, METH_VARARGS, "SoGeoSeparator_getPrimitiveCount(SoGeoSeparator self, SoGetPrimitiveCountAction action)"},
	 { "SoGeoSeparator_swigregister", SoGeoSeparator_swigregister, METH_O, NULL},
	 { "SoGeoSeparator_swiginit", SoGeoSeparator_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedShape_getClassTypeId", _wrap_SoIndexedShape_getClassTypeId, METH_NOARGS, "SoIndexedShape_getClassTypeId() -> SoType"},
	 { "SoIndexedShape_getTypeId", _wrap_SoIndexedShape_getTypeId, METH_O, "SoIndexedShape_getTypeId(SoIndexedShape self) -> SoType"},
	 { "SoIndexedShape_initClass", _wrap_SoIndexedShape_initClass, METH_NOARGS, "SoIndexedShape_initClass()"},
	 { "SoIndexedShape_coordIndex_set", _wrap_SoIndexedShape_coordIndex_set, METH_VARARGS, "SoIndexedShape_coordIndex_set(SoIndexedShape self, SoMFInt32 coordIndex)"},
	 { "SoIndexedShape_coordIndex_get", _wrap_SoIndexedShape_coordIndex_get, METH_O, "SoIndexedShape_coordIndex_get(SoIndexedShape self) -> SoMFInt32"},
	 { "SoIndexedShape_materialIndex_set", _wrap_SoIndexedShape_materialIndex_set, METH_VARARGS, "SoIndexedShape_materialIndex_set(SoIndexedShape self, SoMFInt32 materialIndex)"},
	 { "SoIndexedShape_materialIndex_get", _wrap_SoIndexedShape_materialIndex_get, METH_O, "SoIndexedShape_materialIndex_get(SoIndexedShape self) -> SoMFInt32"},
	 { "SoIndexedShape_normalIndex_set", _wrap_SoIndexedShape_normalIndex_set, METH_VARARGS, "SoIndexedShape_normalIndex_set(SoIndexedShape self, SoMFInt32 normalIndex)"},
	 { "SoIndexedShape_normalIndex_get", _wrap_SoIndexedShape_normalIndex_get, METH_O, "SoIndexedShape_normalIndex_get(SoIndexedShape self) -> SoMFInt32"},
	 { "SoIndexedShape_textureCoordIndex_set", _wrap_SoIndexedShape_textureCoordIndex_set, METH_VARARGS, "SoIndexedShape_textureCoordIndex_set(SoIndexedShape self, SoMFInt32 textureCoordIndex)"},
	 { "SoIndexedShape_textureCoordIndex_get", _wrap_SoIndexedShape_textureCoordIndex_get, METH_O, "SoIndexedShape_textureCoordIndex_get(SoIndexedShape self) -> SoMFInt32"},
	 { "SoIndexedShape_swigregister", SoIndexedShape_swigregister, METH_O, NULL},
	 { "SoIndexedFaceSet_getClassTypeId", _wrap_SoIndexedFaceSet_getClassTypeId, METH_NOARGS, "SoIndexedFaceSet_getClassTypeId() -> SoType"},
	 { "SoIndexedFaceSet_getTypeId", _wrap_SoIndexedFaceSet_getTypeId, METH_O, "SoIndexedFaceSet_getTypeId(SoIndexedFaceSet self) -> SoType"},
	 { "SoIndexedFaceSet_initClass", _wrap_SoIndexedFaceSet_initClass, METH_NOARGS, "SoIndexedFaceSet_initClass()"},
	 { "new_SoIndexedFaceSet", _wrap_new_SoIndexedFaceSet, METH_NOARGS, "new_SoIndexedFaceSet() -> SoIndexedFaceSet"},
	 { "SoIndexedFaceSet_GLRender", _wrap_SoIndexedFaceSet_GLRender, METH_VARARGS, "SoIndexedFaceSet_GLRender(SoIndexedFaceSet self, SoGLRenderAction action)"},
	 { "SoIndexedFaceSet_getPrimitiveCount", _wrap_SoIndexedFaceSet_getPrimitiveCount, METH_VARARGS, "SoIndexedFaceSet_getPrimitiveCount(SoIndexedFaceSet self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedFaceSet_generateDefaultNormals", _wrap_SoIndexedFaceSet_generateDefaultNormals, METH_VARARGS, "\n"
		"SoIndexedFaceSet_generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalBundle bundle) -> SbBool\n"
		"SoIndexedFaceSet_generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalCache cache) -> SbBool\n"
		""},
	 { "SoIndexedFaceSet_swigregister", SoIndexedFaceSet_swigregister, METH_O, NULL},
	 { "SoIndexedFaceSet_swiginit", SoIndexedFaceSet_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedLineSet_getClassTypeId", _wrap_SoIndexedLineSet_getClassTypeId, METH_NOARGS, "SoIndexedLineSet_getClassTypeId() -> SoType"},
	 { "SoIndexedLineSet_getTypeId", _wrap_SoIndexedLineSet_getTypeId, METH_O, "SoIndexedLineSet_getTypeId(SoIndexedLineSet self) -> SoType"},
	 { "SoIndexedLineSet_initClass", _wrap_SoIndexedLineSet_initClass, METH_NOARGS, "SoIndexedLineSet_initClass()"},
	 { "new_SoIndexedLineSet", _wrap_new_SoIndexedLineSet, METH_NOARGS, "new_SoIndexedLineSet() -> SoIndexedLineSet"},
	 { "SoIndexedLineSet_GLRender", _wrap_SoIndexedLineSet_GLRender, METH_VARARGS, "SoIndexedLineSet_GLRender(SoIndexedLineSet self, SoGLRenderAction action)"},
	 { "SoIndexedLineSet_getBoundingBox", _wrap_SoIndexedLineSet_getBoundingBox, METH_VARARGS, "SoIndexedLineSet_getBoundingBox(SoIndexedLineSet self, SoGetBoundingBoxAction action)"},
	 { "SoIndexedLineSet_getPrimitiveCount", _wrap_SoIndexedLineSet_getPrimitiveCount, METH_VARARGS, "SoIndexedLineSet_getPrimitiveCount(SoIndexedLineSet self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedLineSet_swigregister", SoIndexedLineSet_swigregister, METH_O, NULL},
	 { "SoIndexedLineSet_swiginit", SoIndexedLineSet_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedNurbsCurve_getClassTypeId", _wrap_SoIndexedNurbsCurve_getClassTypeId, METH_NOARGS, "SoIndexedNurbsCurve_getClassTypeId() -> SoType"},
	 { "SoIndexedNurbsCurve_getTypeId", _wrap_SoIndexedNurbsCurve_getTypeId, METH_O, "SoIndexedNurbsCurve_getTypeId(SoIndexedNurbsCurve self) -> SoType"},
	 { "SoIndexedNurbsCurve_initClass", _wrap_SoIndexedNurbsCurve_initClass, METH_NOARGS, "SoIndexedNurbsCurve_initClass()"},
	 { "new_SoIndexedNurbsCurve", _wrap_new_SoIndexedNurbsCurve, METH_NOARGS, "new_SoIndexedNurbsCurve() -> SoIndexedNurbsCurve"},
	 { "SoIndexedNurbsCurve_numControlPoints_set", _wrap_SoIndexedNurbsCurve_numControlPoints_set, METH_VARARGS, "SoIndexedNurbsCurve_numControlPoints_set(SoIndexedNurbsCurve self, SoSFInt32 numControlPoints)"},
	 { "SoIndexedNurbsCurve_numControlPoints_get", _wrap_SoIndexedNurbsCurve_numControlPoints_get, METH_O, "SoIndexedNurbsCurve_numControlPoints_get(SoIndexedNurbsCurve self) -> SoSFInt32"},
	 { "SoIndexedNurbsCurve_coordIndex_set", _wrap_SoIndexedNurbsCurve_coordIndex_set, METH_VARARGS, "SoIndexedNurbsCurve_coordIndex_set(SoIndexedNurbsCurve self, SoMFInt32 coordIndex)"},
	 { "SoIndexedNurbsCurve_coordIndex_get", _wrap_SoIndexedNurbsCurve_coordIndex_get, METH_O, "SoIndexedNurbsCurve_coordIndex_get(SoIndexedNurbsCurve self) -> SoMFInt32"},
	 { "SoIndexedNurbsCurve_knotVector_set", _wrap_SoIndexedNurbsCurve_knotVector_set, METH_VARARGS, "SoIndexedNurbsCurve_knotVector_set(SoIndexedNurbsCurve self, SoMFFloat knotVector)"},
	 { "SoIndexedNurbsCurve_knotVector_get", _wrap_SoIndexedNurbsCurve_knotVector_get, METH_O, "SoIndexedNurbsCurve_knotVector_get(SoIndexedNurbsCurve self) -> SoMFFloat"},
	 { "SoIndexedNurbsCurve_GLRender", _wrap_SoIndexedNurbsCurve_GLRender, METH_VARARGS, "SoIndexedNurbsCurve_GLRender(SoIndexedNurbsCurve self, SoGLRenderAction action)"},
	 { "SoIndexedNurbsCurve_rayPick", _wrap_SoIndexedNurbsCurve_rayPick, METH_VARARGS, "SoIndexedNurbsCurve_rayPick(SoIndexedNurbsCurve self, SoRayPickAction action)"},
	 { "SoIndexedNurbsCurve_getPrimitiveCount", _wrap_SoIndexedNurbsCurve_getPrimitiveCount, METH_VARARGS, "SoIndexedNurbsCurve_getPrimitiveCount(SoIndexedNurbsCurve self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedNurbsCurve_getBoundingBox", _wrap_SoIndexedNurbsCurve_getBoundingBox, METH_VARARGS, "SoIndexedNurbsCurve_getBoundingBox(SoIndexedNurbsCurve self, SoGetBoundingBoxAction action)"},
	 { "SoIndexedNurbsCurve_sendPrimitive", _wrap_SoIndexedNurbsCurve_sendPrimitive, METH_VARARGS, "SoIndexedNurbsCurve_sendPrimitive(SoIndexedNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"},
	 { "SoIndexedNurbsCurve_swigregister", SoIndexedNurbsCurve_swigregister, METH_O, NULL},
	 { "SoIndexedNurbsCurve_swiginit", SoIndexedNurbsCurve_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedNurbsSurface_getClassTypeId", _wrap_SoIndexedNurbsSurface_getClassTypeId, METH_NOARGS, "SoIndexedNurbsSurface_getClassTypeId() -> SoType"},
	 { "SoIndexedNurbsSurface_getTypeId", _wrap_SoIndexedNurbsSurface_getTypeId, METH_O, "SoIndexedNurbsSurface_getTypeId(SoIndexedNurbsSurface self) -> SoType"},
	 { "SoIndexedNurbsSurface_initClass", _wrap_SoIndexedNurbsSurface_initClass, METH_NOARGS, "SoIndexedNurbsSurface_initClass()"},
	 { "new_SoIndexedNurbsSurface", _wrap_new_SoIndexedNurbsSurface, METH_NOARGS, "new_SoIndexedNurbsSurface() -> SoIndexedNurbsSurface"},
	 { "SoIndexedNurbsSurface_numUControlPoints_set", _wrap_SoIndexedNurbsSurface_numUControlPoints_set, METH_VARARGS, "SoIndexedNurbsSurface_numUControlPoints_set(SoIndexedNurbsSurface self, SoSFInt32 numUControlPoints)"},
	 { "SoIndexedNurbsSurface_numUControlPoints_get", _wrap_SoIndexedNurbsSurface_numUControlPoints_get, METH_O, "SoIndexedNurbsSurface_numUControlPoints_get(SoIndexedNurbsSurface self) -> SoSFInt32"},
	 { "SoIndexedNurbsSurface_numVControlPoints_set", _wrap_SoIndexedNurbsSurface_numVControlPoints_set, METH_VARARGS, "SoIndexedNurbsSurface_numVControlPoints_set(SoIndexedNurbsSurface self, SoSFInt32 numVControlPoints)"},
	 { "SoIndexedNurbsSurface_numVControlPoints_get", _wrap_SoIndexedNurbsSurface_numVControlPoints_get, METH_O, "SoIndexedNurbsSurface_numVControlPoints_get(SoIndexedNurbsSurface self) -> SoSFInt32"},
	 { "SoIndexedNurbsSurface_coordIndex_set", _wrap_SoIndexedNurbsSurface_coordIndex_set, METH_VARARGS, "SoIndexedNurbsSurface_coordIndex_set(SoIndexedNurbsSurface self, SoMFInt32 coordIndex)"},
	 { "SoIndexedNurbsSurface_coordIndex_get", _wrap_SoIndexedNurbsSurface_coordIndex_get, METH_O, "SoIndexedNurbsSurface_coordIndex_get(SoIndexedNurbsSurface self) -> SoMFInt32"},
	 { "SoIndexedNurbsSurface_uKnotVector_set", _wrap_SoIndexedNurbsSurface_uKnotVector_set, METH_VARARGS, "SoIndexedNurbsSurface_uKnotVector_set(SoIndexedNurbsSurface self, SoMFFloat uKnotVector)"},
	 { "SoIndexedNurbsSurface_uKnotVector_get", _wrap_SoIndexedNurbsSurface_uKnotVector_get, METH_O, "SoIndexedNurbsSurface_uKnotVector_get(SoIndexedNurbsSurface self) -> SoMFFloat"},
	 { "SoIndexedNurbsSurface_vKnotVector_set", _wrap_SoIndexedNurbsSurface_vKnotVector_set, METH_VARARGS, "SoIndexedNurbsSurface_vKnotVector_set(SoIndexedNurbsSurface self, SoMFFloat vKnotVector)"},
	 { "SoIndexedNurbsSurface_vKnotVector_get", _wrap_SoIndexedNurbsSurface_vKnotVector_get, METH_O, "SoIndexedNurbsSurface_vKnotVector_get(SoIndexedNurbsSurface self) -> SoMFFloat"},
	 { "SoIndexedNurbsSurface_numSControlPoints_set", _wrap_SoIndexedNurbsSurface_numSControlPoints_set, METH_VARARGS, "SoIndexedNurbsSurface_numSControlPoints_set(SoIndexedNurbsSurface self, SoSFInt32 numSControlPoints)"},
	 { "SoIndexedNurbsSurface_numSControlPoints_get", _wrap_SoIndexedNurbsSurface_numSControlPoints_get, METH_O, "SoIndexedNurbsSurface_numSControlPoints_get(SoIndexedNurbsSurface self) -> SoSFInt32"},
	 { "SoIndexedNurbsSurface_numTControlPoints_set", _wrap_SoIndexedNurbsSurface_numTControlPoints_set, METH_VARARGS, "SoIndexedNurbsSurface_numTControlPoints_set(SoIndexedNurbsSurface self, SoSFInt32 numTControlPoints)"},
	 { "SoIndexedNurbsSurface_numTControlPoints_get", _wrap_SoIndexedNurbsSurface_numTControlPoints_get, METH_O, "SoIndexedNurbsSurface_numTControlPoints_get(SoIndexedNurbsSurface self) -> SoSFInt32"},
	 { "SoIndexedNurbsSurface_textureCoordIndex_set", _wrap_SoIndexedNurbsSurface_textureCoordIndex_set, METH_VARARGS, "SoIndexedNurbsSurface_textureCoordIndex_set(SoIndexedNurbsSurface self, SoMFInt32 textureCoordIndex)"},
	 { "SoIndexedNurbsSurface_textureCoordIndex_get", _wrap_SoIndexedNurbsSurface_textureCoordIndex_get, METH_O, "SoIndexedNurbsSurface_textureCoordIndex_get(SoIndexedNurbsSurface self) -> SoMFInt32"},
	 { "SoIndexedNurbsSurface_sKnotVector_set", _wrap_SoIndexedNurbsSurface_sKnotVector_set, METH_VARARGS, "SoIndexedNurbsSurface_sKnotVector_set(SoIndexedNurbsSurface self, SoMFFloat sKnotVector)"},
	 { "SoIndexedNurbsSurface_sKnotVector_get", _wrap_SoIndexedNurbsSurface_sKnotVector_get, METH_O, "SoIndexedNurbsSurface_sKnotVector_get(SoIndexedNurbsSurface self) -> SoMFFloat"},
	 { "SoIndexedNurbsSurface_tKnotVector_set", _wrap_SoIndexedNurbsSurface_tKnotVector_set, METH_VARARGS, "SoIndexedNurbsSurface_tKnotVector_set(SoIndexedNurbsSurface self, SoMFFloat tKnotVector)"},
	 { "SoIndexedNurbsSurface_tKnotVector_get", _wrap_SoIndexedNurbsSurface_tKnotVector_get, METH_O, "SoIndexedNurbsSurface_tKnotVector_get(SoIndexedNurbsSurface self) -> SoMFFloat"},
	 { "SoIndexedNurbsSurface_GLRender", _wrap_SoIndexedNurbsSurface_GLRender, METH_VARARGS, "SoIndexedNurbsSurface_GLRender(SoIndexedNurbsSurface self, SoGLRenderAction action)"},
	 { "SoIndexedNurbsSurface_rayPick", _wrap_SoIndexedNurbsSurface_rayPick, METH_VARARGS, "SoIndexedNurbsSurface_rayPick(SoIndexedNurbsSurface self, SoRayPickAction action)"},
	 { "SoIndexedNurbsSurface_getPrimitiveCount", _wrap_SoIndexedNurbsSurface_getPrimitiveCount, METH_VARARGS, "SoIndexedNurbsSurface_getPrimitiveCount(SoIndexedNurbsSurface self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedNurbsSurface_sendPrimitive", _wrap_SoIndexedNurbsSurface_sendPrimitive, METH_VARARGS, "SoIndexedNurbsSurface_sendPrimitive(SoIndexedNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"},
	 { "SoIndexedNurbsSurface_swigregister", SoIndexedNurbsSurface_swigregister, METH_O, NULL},
	 { "SoIndexedNurbsSurface_swiginit", SoIndexedNurbsSurface_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedTriangleStripSet_getClassTypeId", _wrap_SoIndexedTriangleStripSet_getClassTypeId, METH_NOARGS, "SoIndexedTriangleStripSet_getClassTypeId() -> SoType"},
	 { "SoIndexedTriangleStripSet_getTypeId", _wrap_SoIndexedTriangleStripSet_getTypeId, METH_O, "SoIndexedTriangleStripSet_getTypeId(SoIndexedTriangleStripSet self) -> SoType"},
	 { "SoIndexedTriangleStripSet_initClass", _wrap_SoIndexedTriangleStripSet_initClass, METH_NOARGS, "SoIndexedTriangleStripSet_initClass()"},
	 { "new_SoIndexedTriangleStripSet", _wrap_new_SoIndexedTriangleStripSet, METH_NOARGS, "new_SoIndexedTriangleStripSet() -> SoIndexedTriangleStripSet"},
	 { "SoIndexedTriangleStripSet_GLRender", _wrap_SoIndexedTriangleStripSet_GLRender, METH_VARARGS, "SoIndexedTriangleStripSet_GLRender(SoIndexedTriangleStripSet self, SoGLRenderAction action)"},
	 { "SoIndexedTriangleStripSet_getPrimitiveCount", _wrap_SoIndexedTriangleStripSet_getPrimitiveCount, METH_VARARGS, "SoIndexedTriangleStripSet_getPrimitiveCount(SoIndexedTriangleStripSet self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedTriangleStripSet_generateDefaultNormals", _wrap_SoIndexedTriangleStripSet_generateDefaultNormals, METH_VARARGS, "SoIndexedTriangleStripSet_generateDefaultNormals(SoIndexedTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"},
	 { "SoIndexedTriangleStripSet_swigregister", SoIndexedTriangleStripSet_swigregister, METH_O, NULL},
	 { "SoIndexedTriangleStripSet_swiginit", SoIndexedTriangleStripSet_swiginit, METH_VARARGS, NULL},
	 { "SoInfo_getClassTypeId", _wrap_SoInfo_getClassTypeId, METH_NOARGS, "SoInfo_getClassTypeId() -> SoType"},
	 { "SoInfo_getTypeId", _wrap_SoInfo_getTypeId, METH_O, "SoInfo_getTypeId(SoInfo self) -> SoType"},
	 { "SoInfo_initClass", _wrap_SoInfo_initClass, METH_NOARGS, "SoInfo_initClass()"},
	 { "new_SoInfo", _wrap_new_SoInfo, METH_NOARGS, "new_SoInfo() -> SoInfo"},
	 { "SoInfo_string_set", _wrap_SoInfo_string_set, METH_VARARGS, "SoInfo_string_set(SoInfo self, SoSFString string)"},
	 { "SoInfo_string_get", _wrap_SoInfo_string_get, METH_O, "SoInfo_string_get(SoInfo self) -> SoSFString"},
	 { "SoInfo_swigregister", SoInfo_swigregister, METH_O, NULL},
	 { "SoInfo_swiginit", SoInfo_swiginit, METH_VARARGS, NULL},
	 { "SoLabel_getClassTypeId", _wrap_SoLabel_getClassTypeId, METH_NOARGS, "SoLabel_getClassTypeId() -> SoType"},
	 { "SoLabel_getTypeId", _wrap_SoLabel_getTypeId, METH_O, "SoLabel_getTypeId(SoLabel self) -> SoType"},
	 { "SoLabel_initClass", _wrap_SoLabel_initClass, METH_NOARGS, "SoLabel_initClass()"},
	 { "new_SoLabel", _wrap_new_SoLabel, METH_NOARGS, "new_SoLabel() -> SoLabel"},
	 { "SoLabel_label_set", _wrap_SoLabel_label_set, METH_VARARGS, "SoLabel_label_set(SoLabel self, SoSFName label)"},
	 { "SoLabel_label_get", _wrap_SoLabel_label_get, METH_O, "SoLabel_label_get(SoLabel self) -> SoSFName"},
	 { "SoLabel_swigregister", SoLabel_swigregister, METH_O, NULL},
	 { "SoLabel_swiginit", SoLabel_swiginit, METH_VARARGS, NULL},
	 { "SoLevelOfDetail_getClassTypeId", _wrap_SoLevelOfDetail_getClassTypeId, METH_NOARGS, "SoLevelOfDetail_getClassTypeId() -> SoType"},
	 { "SoLevelOfDetail_getTypeId", _wrap_SoLevelOfDetail_getTypeId, METH_O, "SoLevelOfDetail_getTypeId(SoLevelOfDetail self) -> SoType"},
	 { "SoLevelOfDetail_initClass", _wrap_SoLevelOfDetail_initClass, METH_NOARGS, "SoLevelOfDetail_initClass()"},
	 { "new_SoLevelOfDetail", _wrap_new_SoLevelOfDetail, METH_VARARGS, "\n"
		"SoLevelOfDetail()\n"
		"new_SoLevelOfDetail(int numchildren) -> SoLevelOfDetail\n"
		""},
	 { "SoLevelOfDetail_screenArea_set", _wrap_SoLevelOfDetail_screenArea_set, METH_VARARGS, "SoLevelOfDetail_screenArea_set(SoLevelOfDetail self, SoMFFloat screenArea)"},
	 { "SoLevelOfDetail_screenArea_get", _wrap_SoLevelOfDetail_screenArea_get, METH_O, "SoLevelOfDetail_screenArea_get(SoLevelOfDetail self) -> SoMFFloat"},
	 { "SoLevelOfDetail_doAction", _wrap_SoLevelOfDetail_doAction, METH_VARARGS, "SoLevelOfDetail_doAction(SoLevelOfDetail self, SoAction action)"},
	 { "SoLevelOfDetail_callback", _wrap_SoLevelOfDetail_callback, METH_VARARGS, "SoLevelOfDetail_callback(SoLevelOfDetail self, SoCallbackAction action)"},
	 { "SoLevelOfDetail_GLRender", _wrap_SoLevelOfDetail_GLRender, METH_VARARGS, "SoLevelOfDetail_GLRender(SoLevelOfDetail self, SoGLRenderAction action)"},
	 { "SoLevelOfDetail_rayPick", _wrap_SoLevelOfDetail_rayPick, METH_VARARGS, "SoLevelOfDetail_rayPick(SoLevelOfDetail self, SoRayPickAction action)"},
	 { "SoLevelOfDetail_getBoundingBox", _wrap_SoLevelOfDetail_getBoundingBox, METH_VARARGS, "SoLevelOfDetail_getBoundingBox(SoLevelOfDetail self, SoGetBoundingBoxAction action)"},
	 { "SoLevelOfDetail_audioRender", _wrap_SoLevelOfDetail_audioRender, METH_VARARGS, "SoLevelOfDetail_audioRender(SoLevelOfDetail self, SoAudioRenderAction action)"},
	 { "SoLevelOfDetail_notify", _wrap_SoLevelOfDetail_notify, METH_VARARGS, "SoLevelOfDetail_notify(SoLevelOfDetail self, SoNotList nl)"},
	 { "SoLevelOfDetail_swigregister", SoLevelOfDetail_swigregister, METH_O, NULL},
	 { "SoLevelOfDetail_swiginit", SoLevelOfDetail_swiginit, METH_VARARGS, NULL},
	 { "SoProfile_getClassTypeId", _wrap_SoProfile_getClassTypeId, METH_NOARGS, "SoProfile_getClassTypeId() -> SoType"},
	 { "SoProfile_getTypeId", _wrap_SoProfile_getTypeId, METH_O, "SoProfile_getTypeId(SoProfile self) -> SoType"},
	 { "SoProfile_initClass", _wrap_SoProfile_initClass, METH_NOARGS, "SoProfile_initClass()"},
	 { "SoProfile_index_set", _wrap_SoProfile_index_set, METH_VARARGS, "SoProfile_index_set(SoProfile self, SoMFInt32 index)"},
	 { "SoProfile_index_get", _wrap_SoProfile_index_get, METH_O, "SoProfile_index_get(SoProfile self) -> SoMFInt32"},
	 { "SoProfile_linkage_set", _wrap_SoProfile_linkage_set, METH_VARARGS, "SoProfile_linkage_set(SoProfile self, SoSFEnum linkage)"},
	 { "SoProfile_linkage_get", _wrap_SoProfile_linkage_get, METH_O, "SoProfile_linkage_get(SoProfile self) -> SoSFEnum"},
	 { "SoProfile_doAction", _wrap_SoProfile_doAction, METH_VARARGS, "SoProfile_doAction(SoProfile self, SoAction action)"},
	 { "SoProfile_callback", _wrap_SoProfile_callback, METH_VARARGS, "SoProfile_callback(SoProfile self, SoCallbackAction action)"},
	 { "SoProfile_GLRender", _wrap_SoProfile_GLRender, METH_VARARGS, "SoProfile_GLRender(SoProfile self, SoGLRenderAction action)"},
	 { "SoProfile_getBoundingBox", _wrap_SoProfile_getBoundingBox, METH_VARARGS, "SoProfile_getBoundingBox(SoProfile self, SoGetBoundingBoxAction action)"},
	 { "SoProfile_pick", _wrap_SoProfile_pick, METH_VARARGS, "SoProfile_pick(SoProfile self, SoPickAction action)"},
	 { "SoProfile_getPrimitiveCount", _wrap_SoProfile_getPrimitiveCount, METH_VARARGS, "SoProfile_getPrimitiveCount(SoProfile self, SoGetPrimitiveCountAction action)"},
	 { "SoProfile_getTrimCurve", _wrap_SoProfile_getTrimCurve, METH_VARARGS, "SoProfile_getTrimCurve(SoProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"},
	 { "SoProfile_getVertices", _wrap_SoProfile_getVertices, METH_VARARGS, "SoProfile_getVertices(SoProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"},
	 { "SoProfile_swigregister", SoProfile_swigregister, METH_O, NULL},
	 { "SoLinearProfile_getClassTypeId", _wrap_SoLinearProfile_getClassTypeId, METH_NOARGS, "SoLinearProfile_getClassTypeId() -> SoType"},
	 { "SoLinearProfile_getTypeId", _wrap_SoLinearProfile_getTypeId, METH_O, "SoLinearProfile_getTypeId(SoLinearProfile self) -> SoType"},
	 { "SoLinearProfile_initClass", _wrap_SoLinearProfile_initClass, METH_NOARGS, "SoLinearProfile_initClass()"},
	 { "new_SoLinearProfile", _wrap_new_SoLinearProfile, METH_NOARGS, "new_SoLinearProfile() -> SoLinearProfile"},
	 { "SoLinearProfile_getTrimCurve", _wrap_SoLinearProfile_getTrimCurve, METH_VARARGS, "SoLinearProfile_getTrimCurve(SoLinearProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"},
	 { "SoLinearProfile_getVertices", _wrap_SoLinearProfile_getVertices, METH_VARARGS, "SoLinearProfile_getVertices(SoLinearProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"},
	 { "SoLinearProfile_swigregister", SoLinearProfile_swigregister, METH_O, NULL},
	 { "SoLinearProfile_swiginit", SoLinearProfile_swiginit, METH_VARARGS, NULL},
	 { "SoLineSet_getClassTypeId", _wrap_SoLineSet_getClassTypeId, METH_NOARGS, "SoLineSet_getClassTypeId() -> SoType"},
	 { "SoLineSet_getTypeId", _wrap_SoLineSet_getTypeId, METH_O, "SoLineSet_getTypeId(SoLineSet self) -> SoType"},
	 { "SoLineSet_initClass", _wrap_SoLineSet_initClass, METH_NOARGS, "SoLineSet_initClass()"},
	 { "new_SoLineSet", _wrap_new_SoLineSet, METH_NOARGS, "new_SoLineSet() -> SoLineSet"},
	 { "SoLineSet_numVertices_set", _wrap_SoLineSet_numVertices_set, METH_VARARGS, "SoLineSet_numVertices_set(SoLineSet self, SoMFInt32 numVertices)"},
	 { "SoLineSet_numVertices_get", _wrap_SoLineSet_numVertices_get, METH_O, "SoLineSet_numVertices_get(SoLineSet self) -> SoMFInt32"},
	 { "SoLineSet_GLRender", _wrap_SoLineSet_GLRender, METH_VARARGS, "SoLineSet_GLRender(SoLineSet self, SoGLRenderAction action)"},
	 { "SoLineSet_getBoundingBox", _wrap_SoLineSet_getBoundingBox, METH_VARARGS, "SoLineSet_getBoundingBox(SoLineSet self, SoGetBoundingBoxAction action)"},
	 { "SoLineSet_getPrimitiveCount", _wrap_SoLineSet_getPrimitiveCount, METH_VARARGS, "SoLineSet_getPrimitiveCount(SoLineSet self, SoGetPrimitiveCountAction action)"},
	 { "SoLineSet_swigregister", SoLineSet_swigregister, METH_O, NULL},
	 { "SoLineSet_swiginit", SoLineSet_swiginit, METH_VARARGS, NULL},
	 { "SoListener_getClassTypeId", _wrap_SoListener_getClassTypeId, METH_NOARGS, "SoListener_getClassTypeId() -> SoType"},
	 { "SoListener_getTypeId", _wrap_SoListener_getTypeId, METH_O, "SoListener_getTypeId(SoListener self) -> SoType"},
	 { "SoListener_initClass", _wrap_SoListener_initClass, METH_NOARGS, "SoListener_initClass()"},
	 { "new_SoListener", _wrap_new_SoListener, METH_NOARGS, "new_SoListener() -> SoListener"},
	 { "SoListener_position_set", _wrap_SoListener_position_set, METH_VARARGS, "SoListener_position_set(SoListener self, SoSFVec3f position)"},
	 { "SoListener_position_get", _wrap_SoListener_position_get, METH_O, "SoListener_position_get(SoListener self) -> SoSFVec3f"},
	 { "SoListener_orientation_set", _wrap_SoListener_orientation_set, METH_VARARGS, "SoListener_orientation_set(SoListener self, SoSFRotation orientation)"},
	 { "SoListener_orientation_get", _wrap_SoListener_orientation_get, METH_O, "SoListener_orientation_get(SoListener self) -> SoSFRotation"},
	 { "SoListener_gain_set", _wrap_SoListener_gain_set, METH_VARARGS, "SoListener_gain_set(SoListener self, SoSFFloat gain)"},
	 { "SoListener_gain_get", _wrap_SoListener_gain_get, METH_O, "SoListener_gain_get(SoListener self) -> SoSFFloat"},
	 { "SoListener_dopplerVelocity_set", _wrap_SoListener_dopplerVelocity_set, METH_VARARGS, "SoListener_dopplerVelocity_set(SoListener self, SoSFVec3f dopplerVelocity)"},
	 { "SoListener_dopplerVelocity_get", _wrap_SoListener_dopplerVelocity_get, METH_O, "SoListener_dopplerVelocity_get(SoListener self) -> SoSFVec3f"},
	 { "SoListener_dopplerFactor_set", _wrap_SoListener_dopplerFactor_set, METH_VARARGS, "SoListener_dopplerFactor_set(SoListener self, SoSFFloat dopplerFactor)"},
	 { "SoListener_dopplerFactor_get", _wrap_SoListener_dopplerFactor_get, METH_O, "SoListener_dopplerFactor_get(SoListener self) -> SoSFFloat"},
	 { "SoListener_swigregister", SoListener_swigregister, METH_O, NULL},
	 { "SoListener_swiginit", SoListener_swiginit, METH_VARARGS, NULL},
	 { "SoLocateHighlight_getClassTypeId", _wrap_SoLocateHighlight_getClassTypeId, METH_NOARGS, "SoLocateHighlight_getClassTypeId() -> SoType"},
	 { "SoLocateHighlight_getTypeId", _wrap_SoLocateHighlight_getTypeId, METH_O, "SoLocateHighlight_getTypeId(SoLocateHighlight self) -> SoType"},
	 { "SoLocateHighlight_initClass", _wrap_SoLocateHighlight_initClass, METH_NOARGS, "SoLocateHighlight_initClass()"},
	 { "new_SoLocateHighlight", _wrap_new_SoLocateHighlight, METH_NOARGS, "new_SoLocateHighlight() -> SoLocateHighlight"},
	 { "SoLocateHighlight_color_set", _wrap_SoLocateHighlight_color_set, METH_VARARGS, "SoLocateHighlight_color_set(SoLocateHighlight self, SoSFColor color)"},
	 { "SoLocateHighlight_color_get", _wrap_SoLocateHighlight_color_get, METH_O, "SoLocateHighlight_color_get(SoLocateHighlight self) -> SoSFColor"},
	 { "SoLocateHighlight_style_set", _wrap_SoLocateHighlight_style_set, METH_VARARGS, "SoLocateHighlight_style_set(SoLocateHighlight self, SoSFEnum style)"},
	 { "SoLocateHighlight_style_get", _wrap_SoLocateHighlight_style_get, METH_O, "SoLocateHighlight_style_get(SoLocateHighlight self) -> SoSFEnum"},
	 { "SoLocateHighlight_mode_set", _wrap_SoLocateHighlight_mode_set, METH_VARARGS, "SoLocateHighlight_mode_set(SoLocateHighlight self, SoSFEnum mode)"},
	 { "SoLocateHighlight_mode_get", _wrap_SoLocateHighlight_mode_get, METH_O, "SoLocateHighlight_mode_get(SoLocateHighlight self) -> SoSFEnum"},
	 { "SoLocateHighlight_handleEvent", _wrap_SoLocateHighlight_handleEvent, METH_VARARGS, "SoLocateHighlight_handleEvent(SoLocateHighlight self, SoHandleEventAction action)"},
	 { "SoLocateHighlight_GLRenderBelowPath", _wrap_SoLocateHighlight_GLRenderBelowPath, METH_VARARGS, "SoLocateHighlight_GLRenderBelowPath(SoLocateHighlight self, SoGLRenderAction action)"},
	 { "SoLocateHighlight_GLRenderInPath", _wrap_SoLocateHighlight_GLRenderInPath, METH_VARARGS, "SoLocateHighlight_GLRenderInPath(SoLocateHighlight self, SoGLRenderAction action)"},
	 { "SoLocateHighlight_turnOffCurrentHighlight", _wrap_SoLocateHighlight_turnOffCurrentHighlight, METH_O, "SoLocateHighlight_turnOffCurrentHighlight(SoGLRenderAction action)"},
	 { "SoLocateHighlight_swigregister", SoLocateHighlight_swigregister, METH_O, NULL},
	 { "SoLocateHighlight_swiginit", SoLocateHighlight_swiginit, METH_VARARGS, NULL},
	 { "SoLOD_getClassTypeId", _wrap_SoLOD_getClassTypeId, METH_NOARGS, "SoLOD_getClassTypeId() -> SoType"},
	 { "SoLOD_getTypeId", _wrap_SoLOD_getTypeId, METH_O, "SoLOD_getTypeId(SoLOD self) -> SoType"},
	 { "new_SoLOD", _wrap_new_SoLOD, METH_VARARGS, "\n"
		"SoLOD()\n"
		"new_SoLOD(int numchildren) -> SoLOD\n"
		""},
	 { "SoLOD_initClass", _wrap_SoLOD_initClass, METH_NOARGS, "SoLOD_initClass()"},
	 { "SoLOD_range_set", _wrap_SoLOD_range_set, METH_VARARGS, "SoLOD_range_set(SoLOD self, SoMFFloat range)"},
	 { "SoLOD_range_get", _wrap_SoLOD_range_get, METH_O, "SoLOD_range_get(SoLOD self) -> SoMFFloat"},
	 { "SoLOD_center_set", _wrap_SoLOD_center_set, METH_VARARGS, "SoLOD_center_set(SoLOD self, SoSFVec3f center)"},
	 { "SoLOD_center_get", _wrap_SoLOD_center_get, METH_O, "SoLOD_center_get(SoLOD self) -> SoSFVec3f"},
	 { "SoLOD_doAction", _wrap_SoLOD_doAction, METH_VARARGS, "SoLOD_doAction(SoLOD self, SoAction action)"},
	 { "SoLOD_callback", _wrap_SoLOD_callback, METH_VARARGS, "SoLOD_callback(SoLOD self, SoCallbackAction action)"},
	 { "SoLOD_GLRender", _wrap_SoLOD_GLRender, METH_VARARGS, "SoLOD_GLRender(SoLOD self, SoGLRenderAction action)"},
	 { "SoLOD_GLRenderBelowPath", _wrap_SoLOD_GLRenderBelowPath, METH_VARARGS, "SoLOD_GLRenderBelowPath(SoLOD self, SoGLRenderAction action)"},
	 { "SoLOD_GLRenderInPath", _wrap_SoLOD_GLRenderInPath, METH_VARARGS, "SoLOD_GLRenderInPath(SoLOD self, SoGLRenderAction action)"},
	 { "SoLOD_GLRenderOffPath", _wrap_SoLOD_GLRenderOffPath, METH_VARARGS, "SoLOD_GLRenderOffPath(SoLOD self, SoGLRenderAction action)"},
	 { "SoLOD_rayPick", _wrap_SoLOD_rayPick, METH_VARARGS, "SoLOD_rayPick(SoLOD self, SoRayPickAction action)"},
	 { "SoLOD_getBoundingBox", _wrap_SoLOD_getBoundingBox, METH_VARARGS, "SoLOD_getBoundingBox(SoLOD self, SoGetBoundingBoxAction action)"},
	 { "SoLOD_getPrimitiveCount", _wrap_SoLOD_getPrimitiveCount, METH_VARARGS, "SoLOD_getPrimitiveCount(SoLOD self, SoGetPrimitiveCountAction action)"},
	 { "SoLOD_audioRender", _wrap_SoLOD_audioRender, METH_VARARGS, "SoLOD_audioRender(SoLOD self, SoAudioRenderAction action)"},
	 { "SoLOD_notify", _wrap_SoLOD_notify, METH_VARARGS, "SoLOD_notify(SoLOD self, SoNotList nl)"},
	 { "SoLOD_swigregister", SoLOD_swigregister, METH_O, NULL},
	 { "SoLOD_swiginit", SoLOD_swiginit, METH_VARARGS, NULL},
	 { "SoPointSet_getClassTypeId", _wrap_SoPointSet_getClassTypeId, METH_NOARGS, "SoPointSet_getClassTypeId() -> SoType"},
	 { "SoPointSet_getTypeId", _wrap_SoPointSet_getTypeId, METH_O, "SoPointSet_getTypeId(SoPointSet self) -> SoType"},
	 { "SoPointSet_initClass", _wrap_SoPointSet_initClass, METH_NOARGS, "SoPointSet_initClass()"},
	 { "new_SoPointSet", _wrap_new_SoPointSet, METH_NOARGS, "new_SoPointSet() -> SoPointSet"},
	 { "SoPointSet_numPoints_set", _wrap_SoPointSet_numPoints_set, METH_VARARGS, "SoPointSet_numPoints_set(SoPointSet self, SoSFInt32 numPoints)"},
	 { "SoPointSet_numPoints_get", _wrap_SoPointSet_numPoints_get, METH_O, "SoPointSet_numPoints_get(SoPointSet self) -> SoSFInt32"},
	 { "SoPointSet_GLRender", _wrap_SoPointSet_GLRender, METH_VARARGS, "SoPointSet_GLRender(SoPointSet self, SoGLRenderAction action)"},
	 { "SoPointSet_getBoundingBox", _wrap_SoPointSet_getBoundingBox, METH_VARARGS, "SoPointSet_getBoundingBox(SoPointSet self, SoGetBoundingBoxAction action)"},
	 { "SoPointSet_getPrimitiveCount", _wrap_SoPointSet_getPrimitiveCount, METH_VARARGS, "SoPointSet_getPrimitiveCount(SoPointSet self, SoGetPrimitiveCountAction action)"},
	 { "SoPointSet_swigregister", SoPointSet_swigregister, METH_O, NULL},
	 { "SoPointSet_swiginit", SoPointSet_swiginit, METH_VARARGS, NULL},
	 { "SoMarkerSet_getClassTypeId", _wrap_SoMarkerSet_getClassTypeId, METH_NOARGS, "SoMarkerSet_getClassTypeId() -> SoType"},
	 { "SoMarkerSet_getTypeId", _wrap_SoMarkerSet_getTypeId, METH_O, "SoMarkerSet_getTypeId(SoMarkerSet self) -> SoType"},
	 { "SoMarkerSet_initClass", _wrap_SoMarkerSet_initClass, METH_NOARGS, "SoMarkerSet_initClass()"},
	 { "new_SoMarkerSet", _wrap_new_SoMarkerSet, METH_NOARGS, "new_SoMarkerSet() -> SoMarkerSet"},
	 { "SoMarkerSet_markerIndex_set", _wrap_SoMarkerSet_markerIndex_set, METH_VARARGS, "SoMarkerSet_markerIndex_set(SoMarkerSet self, SoMFInt32 markerIndex)"},
	 { "SoMarkerSet_markerIndex_get", _wrap_SoMarkerSet_markerIndex_get, METH_O, "SoMarkerSet_markerIndex_get(SoMarkerSet self) -> SoMFInt32"},
	 { "SoMarkerSet_GLRender", _wrap_SoMarkerSet_GLRender, METH_VARARGS, "SoMarkerSet_GLRender(SoMarkerSet self, SoGLRenderAction action)"},
	 { "SoMarkerSet_getPrimitiveCount", _wrap_SoMarkerSet_getPrimitiveCount, METH_VARARGS, "SoMarkerSet_getPrimitiveCount(SoMarkerSet self, SoGetPrimitiveCountAction action)"},
	 { "SoMarkerSet_getNumDefinedMarkers", _wrap_SoMarkerSet_getNumDefinedMarkers, METH_NOARGS, "SoMarkerSet_getNumDefinedMarkers() -> int"},
	 { "SoMarkerSet_getMarker", _wrap_SoMarkerSet_getMarker, METH_VARARGS, "SoMarkerSet_getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"},
	 { "SoMarkerSet_removeMarker", _wrap_SoMarkerSet_removeMarker, METH_O, "SoMarkerSet_removeMarker(int idx) -> SbBool"},
	 { "SoMarkerSet_isMarkerBitSet", _wrap_SoMarkerSet_isMarkerBitSet, METH_VARARGS, "SoMarkerSet_isMarkerBitSet(int idx, int bitNumber) -> SbBool"},
	 { "SoMarkerSet_addMarker", _wrap_SoMarkerSet_addMarker, METH_VARARGS, "\n"
		"SoMarkerSet_addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)\n"
		"SoMarkerSet_addMarker(int idx, SbVec2s size, PyObject * string, SbBool isLSBFirst=1, SbBool isUpToDown=1)\n"
		""},
	 { "SoMarkerSet_swigregister", SoMarkerSet_swigregister, METH_O, NULL},
	 { "SoMarkerSet_swiginit", SoMarkerSet_swiginit, METH_VARARGS, NULL},
	 { "SoMaterial_getClassTypeId", _wrap_SoMaterial_getClassTypeId, METH_NOARGS, "SoMaterial_getClassTypeId() -> SoType"},
	 { "SoMaterial_getTypeId", _wrap_SoMaterial_getTypeId, METH_O, "SoMaterial_getTypeId(SoMaterial self) -> SoType"},
	 { "SoMaterial_initClass", _wrap_SoMaterial_initClass, METH_NOARGS, "SoMaterial_initClass()"},
	 { "new_SoMaterial", _wrap_new_SoMaterial, METH_NOARGS, "new_SoMaterial() -> SoMaterial"},
	 { "SoMaterial_ambientColor_set", _wrap_SoMaterial_ambientColor_set, METH_VARARGS, "SoMaterial_ambientColor_set(SoMaterial self, SoMFColor ambientColor)"},
	 { "SoMaterial_ambientColor_get", _wrap_SoMaterial_ambientColor_get, METH_O, "SoMaterial_ambientColor_get(SoMaterial self) -> SoMFColor"},
	 { "SoMaterial_diffuseColor_set", _wrap_SoMaterial_diffuseColor_set, METH_VARARGS, "SoMaterial_diffuseColor_set(SoMaterial self, SoMFColor diffuseColor)"},
	 { "SoMaterial_diffuseColor_get", _wrap_SoMaterial_diffuseColor_get, METH_O, "SoMaterial_diffuseColor_get(SoMaterial self) -> SoMFColor"},
	 { "SoMaterial_specularColor_set", _wrap_SoMaterial_specularColor_set, METH_VARARGS, "SoMaterial_specularColor_set(SoMaterial self, SoMFColor specularColor)"},
	 { "SoMaterial_specularColor_get", _wrap_SoMaterial_specularColor_get, METH_O, "SoMaterial_specularColor_get(SoMaterial self) -> SoMFColor"},
	 { "SoMaterial_emissiveColor_set", _wrap_SoMaterial_emissiveColor_set, METH_VARARGS, "SoMaterial_emissiveColor_set(SoMaterial self, SoMFColor emissiveColor)"},
	 { "SoMaterial_emissiveColor_get", _wrap_SoMaterial_emissiveColor_get, METH_O, "SoMaterial_emissiveColor_get(SoMaterial self) -> SoMFColor"},
	 { "SoMaterial_shininess_set", _wrap_SoMaterial_shininess_set, METH_VARARGS, "SoMaterial_shininess_set(SoMaterial self, SoMFFloat shininess)"},
	 { "SoMaterial_shininess_get", _wrap_SoMaterial_shininess_get, METH_O, "SoMaterial_shininess_get(SoMaterial self) -> SoMFFloat"},
	 { "SoMaterial_transparency_set", _wrap_SoMaterial_transparency_set, METH_VARARGS, "SoMaterial_transparency_set(SoMaterial self, SoMFFloat transparency)"},
	 { "SoMaterial_transparency_get", _wrap_SoMaterial_transparency_get, METH_O, "SoMaterial_transparency_get(SoMaterial self) -> SoMFFloat"},
	 { "SoMaterial_doAction", _wrap_SoMaterial_doAction, METH_VARARGS, "SoMaterial_doAction(SoMaterial self, SoAction action)"},
	 { "SoMaterial_GLRender", _wrap_SoMaterial_GLRender, METH_VARARGS, "SoMaterial_GLRender(SoMaterial self, SoGLRenderAction action)"},
	 { "SoMaterial_callback", _wrap_SoMaterial_callback, METH_VARARGS, "SoMaterial_callback(SoMaterial self, SoCallbackAction action)"},
	 { "SoMaterial_swigregister", SoMaterial_swigregister, METH_O, NULL},
	 { "SoMaterial_swiginit", SoMaterial_swiginit, METH_VARARGS, NULL},
	 { "SoMatrixTransform_getClassTypeId", _wrap_SoMatrixTransform_getClassTypeId, METH_NOARGS, "SoMatrixTransform_getClassTypeId() -> SoType"},
	 { "SoMatrixTransform_getTypeId", _wrap_SoMatrixTransform_getTypeId, METH_O, "SoMatrixTransform_getTypeId(SoMatrixTransform self) -> SoType"},
	 { "SoMatrixTransform_initClass", _wrap_SoMatrixTransform_initClass, METH_NOARGS, "SoMatrixTransform_initClass()"},
	 { "new_SoMatrixTransform", _wrap_new_SoMatrixTransform, METH_NOARGS, "new_SoMatrixTransform() -> SoMatrixTransform"},
	 { "SoMatrixTransform_matrix_set", _wrap_SoMatrixTransform_matrix_set, METH_VARARGS, "SoMatrixTransform_matrix_set(SoMatrixTransform self, SoSFMatrix matrix)"},
	 { "SoMatrixTransform_matrix_get", _wrap_SoMatrixTransform_matrix_get, METH_O, "SoMatrixTransform_matrix_get(SoMatrixTransform self) -> SoSFMatrix"},
	 { "SoMatrixTransform_doAction", _wrap_SoMatrixTransform_doAction, METH_VARARGS, "SoMatrixTransform_doAction(SoMatrixTransform self, SoAction action)"},
	 { "SoMatrixTransform_callback", _wrap_SoMatrixTransform_callback, METH_VARARGS, "SoMatrixTransform_callback(SoMatrixTransform self, SoCallbackAction action)"},
	 { "SoMatrixTransform_GLRender", _wrap_SoMatrixTransform_GLRender, METH_VARARGS, "SoMatrixTransform_GLRender(SoMatrixTransform self, SoGLRenderAction action)"},
	 { "SoMatrixTransform_getBoundingBox", _wrap_SoMatrixTransform_getBoundingBox, METH_VARARGS, "SoMatrixTransform_getBoundingBox(SoMatrixTransform self, SoGetBoundingBoxAction action)"},
	 { "SoMatrixTransform_getMatrix", _wrap_SoMatrixTransform_getMatrix, METH_VARARGS, "SoMatrixTransform_getMatrix(SoMatrixTransform self, SoGetMatrixAction action)"},
	 { "SoMatrixTransform_pick", _wrap_SoMatrixTransform_pick, METH_VARARGS, "SoMatrixTransform_pick(SoMatrixTransform self, SoPickAction action)"},
	 { "SoMatrixTransform_getPrimitiveCount", _wrap_SoMatrixTransform_getPrimitiveCount, METH_VARARGS, "SoMatrixTransform_getPrimitiveCount(SoMatrixTransform self, SoGetPrimitiveCountAction action)"},
	 { "SoMatrixTransform_swigregister", SoMatrixTransform_swigregister, METH_O, NULL},
	 { "SoMatrixTransform_swiginit", SoMatrixTransform_swiginit, METH_VARARGS, NULL},
	 { "SoMultipleCopy_getClassTypeId", _wrap_SoMultipleCopy_getClassTypeId, METH_NOARGS, "SoMultipleCopy_getClassTypeId() -> SoType"},
	 { "SoMultipleCopy_getTypeId", _wrap_SoMultipleCopy_getTypeId, METH_O, "SoMultipleCopy_getTypeId(SoMultipleCopy self) -> SoType"},
	 { "SoMultipleCopy_initClass", _wrap_SoMultipleCopy_initClass, METH_NOARGS, "SoMultipleCopy_initClass()"},
	 { "new_SoMultipleCopy", _wrap_new_SoMultipleCopy, METH_NOARGS, "new_SoMultipleCopy() -> SoMultipleCopy"},
	 { "SoMultipleCopy_matrix_set", _wrap_SoMultipleCopy_matrix_set, METH_VARARGS, "SoMultipleCopy_matrix_set(SoMultipleCopy self, SoMFMatrix matrix)"},
	 { "SoMultipleCopy_matrix_get", _wrap_SoMultipleCopy_matrix_get, METH_O, "SoMultipleCopy_matrix_get(SoMultipleCopy self) -> SoMFMatrix"},
	 { "SoMultipleCopy_affectsState", _wrap_SoMultipleCopy_affectsState, METH_O, "SoMultipleCopy_affectsState(SoMultipleCopy self) -> SbBool"},
	 { "SoMultipleCopy_doAction", _wrap_SoMultipleCopy_doAction, METH_VARARGS, "SoMultipleCopy_doAction(SoMultipleCopy self, SoAction action)"},
	 { "SoMultipleCopy_callback", _wrap_SoMultipleCopy_callback, METH_VARARGS, "SoMultipleCopy_callback(SoMultipleCopy self, SoCallbackAction action)"},
	 { "SoMultipleCopy_GLRender", _wrap_SoMultipleCopy_GLRender, METH_VARARGS, "SoMultipleCopy_GLRender(SoMultipleCopy self, SoGLRenderAction action)"},
	 { "SoMultipleCopy_pick", _wrap_SoMultipleCopy_pick, METH_VARARGS, "SoMultipleCopy_pick(SoMultipleCopy self, SoPickAction action)"},
	 { "SoMultipleCopy_getBoundingBox", _wrap_SoMultipleCopy_getBoundingBox, METH_VARARGS, "SoMultipleCopy_getBoundingBox(SoMultipleCopy self, SoGetBoundingBoxAction action)"},
	 { "SoMultipleCopy_handleEvent", _wrap_SoMultipleCopy_handleEvent, METH_VARARGS, "SoMultipleCopy_handleEvent(SoMultipleCopy self, SoHandleEventAction action)"},
	 { "SoMultipleCopy_getMatrix", _wrap_SoMultipleCopy_getMatrix, METH_VARARGS, "SoMultipleCopy_getMatrix(SoMultipleCopy self, SoGetMatrixAction action)"},
	 { "SoMultipleCopy_search", _wrap_SoMultipleCopy_search, METH_VARARGS, "SoMultipleCopy_search(SoMultipleCopy self, SoSearchAction action)"},
	 { "SoMultipleCopy_getPrimitiveCount", _wrap_SoMultipleCopy_getPrimitiveCount, METH_VARARGS, "SoMultipleCopy_getPrimitiveCount(SoMultipleCopy self, SoGetPrimitiveCountAction action)"},
	 { "SoMultipleCopy_audioRender", _wrap_SoMultipleCopy_audioRender, METH_VARARGS, "SoMultipleCopy_audioRender(SoMultipleCopy self, SoAudioRenderAction action)"},
	 { "SoMultipleCopy_swigregister", SoMultipleCopy_swigregister, METH_O, NULL},
	 { "SoMultipleCopy_swiginit", SoMultipleCopy_swiginit, METH_VARARGS, NULL},
	 { "SoPerspectiveCamera_getClassTypeId", _wrap_SoPerspectiveCamera_getClassTypeId, METH_NOARGS, "SoPerspectiveCamera_getClassTypeId() -> SoType"},
	 { "SoPerspectiveCamera_getTypeId", _wrap_SoPerspectiveCamera_getTypeId, METH_O, "SoPerspectiveCamera_getTypeId(SoPerspectiveCamera self) -> SoType"},
	 { "SoPerspectiveCamera_initClass", _wrap_SoPerspectiveCamera_initClass, METH_NOARGS, "SoPerspectiveCamera_initClass()"},
	 { "new_SoPerspectiveCamera", _wrap_new_SoPerspectiveCamera, METH_NOARGS, "new_SoPerspectiveCamera() -> SoPerspectiveCamera"},
	 { "SoPerspectiveCamera_heightAngle_set", _wrap_SoPerspectiveCamera_heightAngle_set, METH_VARARGS, "SoPerspectiveCamera_heightAngle_set(SoPerspectiveCamera self, SoSFFloat heightAngle)"},
	 { "SoPerspectiveCamera_heightAngle_get", _wrap_SoPerspectiveCamera_heightAngle_get, METH_O, "SoPerspectiveCamera_heightAngle_get(SoPerspectiveCamera self) -> SoSFFloat"},
	 { "SoPerspectiveCamera_scaleHeight", _wrap_SoPerspectiveCamera_scaleHeight, METH_VARARGS, "SoPerspectiveCamera_scaleHeight(SoPerspectiveCamera self, float scalefactor)"},
	 { "SoPerspectiveCamera_getViewVolume", _wrap_SoPerspectiveCamera_getViewVolume, METH_VARARGS, "SoPerspectiveCamera_getViewVolume(SoPerspectiveCamera self, float useaspectratio=0.0) -> SbViewVolume"},
	 { "SoPerspectiveCamera_viewBoundingBox", _wrap_SoPerspectiveCamera_viewBoundingBox, METH_VARARGS, "SoPerspectiveCamera_viewBoundingBox(SoPerspectiveCamera self, SbBox3f box, float aspect, float slack)"},
	 { "SoPerspectiveCamera_swigregister", SoPerspectiveCamera_swigregister, METH_O, NULL},
	 { "SoPerspectiveCamera_swiginit", SoPerspectiveCamera_swiginit, METH_VARARGS, NULL},
	 { "SoReversePerspectiveCamera_getClassTypeId", _wrap_SoReversePerspectiveCamera_getClassTypeId, METH_NOARGS, "SoReversePerspectiveCamera_getClassTypeId() -> SoType"},
	 { "SoReversePerspectiveCamera_getTypeId", _wrap_SoReversePerspectiveCamera_getTypeId, METH_O, "SoReversePerspectiveCamera_getTypeId(SoReversePerspectiveCamera self) -> SoType"},
	 { "SoReversePerspectiveCamera_initClass", _wrap_SoReversePerspectiveCamera_initClass, METH_NOARGS, "SoReversePerspectiveCamera_initClass()"},
	 { "new_SoReversePerspectiveCamera", _wrap_new_SoReversePerspectiveCamera, METH_NOARGS, "new_SoReversePerspectiveCamera() -> SoReversePerspectiveCamera"},
	 { "SoReversePerspectiveCamera_swigregister", SoReversePerspectiveCamera_swigregister, METH_O, NULL},
	 { "SoReversePerspectiveCamera_swiginit", SoReversePerspectiveCamera_swiginit, METH_VARARGS, NULL},
	 { "SoOrthographicCamera_getClassTypeId", _wrap_SoOrthographicCamera_getClassTypeId, METH_NOARGS, "SoOrthographicCamera_getClassTypeId() -> SoType"},
	 { "SoOrthographicCamera_getTypeId", _wrap_SoOrthographicCamera_getTypeId, METH_O, "SoOrthographicCamera_getTypeId(SoOrthographicCamera self) -> SoType"},
	 { "SoOrthographicCamera_initClass", _wrap_SoOrthographicCamera_initClass, METH_NOARGS, "SoOrthographicCamera_initClass()"},
	 { "new_SoOrthographicCamera", _wrap_new_SoOrthographicCamera, METH_NOARGS, "new_SoOrthographicCamera() -> SoOrthographicCamera"},
	 { "SoOrthographicCamera_height_set", _wrap_SoOrthographicCamera_height_set, METH_VARARGS, "SoOrthographicCamera_height_set(SoOrthographicCamera self, SoSFFloat height)"},
	 { "SoOrthographicCamera_height_get", _wrap_SoOrthographicCamera_height_get, METH_O, "SoOrthographicCamera_height_get(SoOrthographicCamera self) -> SoSFFloat"},
	 { "SoOrthographicCamera_scaleHeight", _wrap_SoOrthographicCamera_scaleHeight, METH_VARARGS, "SoOrthographicCamera_scaleHeight(SoOrthographicCamera self, float scalefactor)"},
	 { "SoOrthographicCamera_getViewVolume", _wrap_SoOrthographicCamera_getViewVolume, METH_VARARGS, "SoOrthographicCamera_getViewVolume(SoOrthographicCamera self, float useaspectratio=0.0) -> SbViewVolume"},
	 { "SoOrthographicCamera_viewBoundingBox", _wrap_SoOrthographicCamera_viewBoundingBox, METH_VARARGS, "SoOrthographicCamera_viewBoundingBox(SoOrthographicCamera self, SbBox3f box, float aspect, float slack)"},
	 { "SoOrthographicCamera_swigregister", SoOrthographicCamera_swigregister, METH_O, NULL},
	 { "SoOrthographicCamera_swiginit", SoOrthographicCamera_swiginit, METH_VARARGS, NULL},
	 { "SoFrustumCamera_getClassTypeId", _wrap_SoFrustumCamera_getClassTypeId, METH_NOARGS, "SoFrustumCamera_getClassTypeId() -> SoType"},
	 { "SoFrustumCamera_getTypeId", _wrap_SoFrustumCamera_getTypeId, METH_O, "SoFrustumCamera_getTypeId(SoFrustumCamera self) -> SoType"},
	 { "SoFrustumCamera_initClass", _wrap_SoFrustumCamera_initClass, METH_NOARGS, "SoFrustumCamera_initClass()"},
	 { "new_SoFrustumCamera", _wrap_new_SoFrustumCamera, METH_NOARGS, "new_SoFrustumCamera() -> SoFrustumCamera"},
	 { "SoFrustumCamera_left_set", _wrap_SoFrustumCamera_left_set, METH_VARARGS, "SoFrustumCamera_left_set(SoFrustumCamera self, SoSFFloat left)"},
	 { "SoFrustumCamera_left_get", _wrap_SoFrustumCamera_left_get, METH_O, "SoFrustumCamera_left_get(SoFrustumCamera self) -> SoSFFloat"},
	 { "SoFrustumCamera_right_set", _wrap_SoFrustumCamera_right_set, METH_VARARGS, "SoFrustumCamera_right_set(SoFrustumCamera self, SoSFFloat right)"},
	 { "SoFrustumCamera_right_get", _wrap_SoFrustumCamera_right_get, METH_O, "SoFrustumCamera_right_get(SoFrustumCamera self) -> SoSFFloat"},
	 { "SoFrustumCamera_top_set", _wrap_SoFrustumCamera_top_set, METH_VARARGS, "SoFrustumCamera_top_set(SoFrustumCamera self, SoSFFloat top)"},
	 { "SoFrustumCamera_top_get", _wrap_SoFrustumCamera_top_get, METH_O, "SoFrustumCamera_top_get(SoFrustumCamera self) -> SoSFFloat"},
	 { "SoFrustumCamera_bottom_set", _wrap_SoFrustumCamera_bottom_set, METH_VARARGS, "SoFrustumCamera_bottom_set(SoFrustumCamera self, SoSFFloat bottom)"},
	 { "SoFrustumCamera_bottom_get", _wrap_SoFrustumCamera_bottom_get, METH_O, "SoFrustumCamera_bottom_get(SoFrustumCamera self) -> SoSFFloat"},
	 { "SoFrustumCamera_scaleHeight", _wrap_SoFrustumCamera_scaleHeight, METH_VARARGS, "SoFrustumCamera_scaleHeight(SoFrustumCamera self, float scalefactor)"},
	 { "SoFrustumCamera_getViewVolume", _wrap_SoFrustumCamera_getViewVolume, METH_VARARGS, "SoFrustumCamera_getViewVolume(SoFrustumCamera self, float useaspectratio=0.0) -> SbViewVolume"},
	 { "SoFrustumCamera_swigregister", SoFrustumCamera_swigregister, METH_O, NULL},
	 { "SoFrustumCamera_swiginit", SoFrustumCamera_swiginit, METH_VARARGS, NULL},
	 { "SoQuadMesh_getClassTypeId", _wrap_SoQuadMesh_getClassTypeId, METH_NOARGS, "SoQuadMesh_getClassTypeId() -> SoType"},
	 { "SoQuadMesh_getTypeId", _wrap_SoQuadMesh_getTypeId, METH_O, "SoQuadMesh_getTypeId(SoQuadMesh self) -> SoType"},
	 { "SoQuadMesh_initClass", _wrap_SoQuadMesh_initClass, METH_NOARGS, "SoQuadMesh_initClass()"},
	 { "new_SoQuadMesh", _wrap_new_SoQuadMesh, METH_NOARGS, "new_SoQuadMesh() -> SoQuadMesh"},
	 { "SoQuadMesh_verticesPerColumn_set", _wrap_SoQuadMesh_verticesPerColumn_set, METH_VARARGS, "SoQuadMesh_verticesPerColumn_set(SoQuadMesh self, SoSFInt32 verticesPerColumn)"},
	 { "SoQuadMesh_verticesPerColumn_get", _wrap_SoQuadMesh_verticesPerColumn_get, METH_O, "SoQuadMesh_verticesPerColumn_get(SoQuadMesh self) -> SoSFInt32"},
	 { "SoQuadMesh_verticesPerRow_set", _wrap_SoQuadMesh_verticesPerRow_set, METH_VARARGS, "SoQuadMesh_verticesPerRow_set(SoQuadMesh self, SoSFInt32 verticesPerRow)"},
	 { "SoQuadMesh_verticesPerRow_get", _wrap_SoQuadMesh_verticesPerRow_get, METH_O, "SoQuadMesh_verticesPerRow_get(SoQuadMesh self) -> SoSFInt32"},
	 { "SoQuadMesh_GLRender", _wrap_SoQuadMesh_GLRender, METH_VARARGS, "SoQuadMesh_GLRender(SoQuadMesh self, SoGLRenderAction action)"},
	 { "SoQuadMesh_getPrimitiveCount", _wrap_SoQuadMesh_getPrimitiveCount, METH_VARARGS, "SoQuadMesh_getPrimitiveCount(SoQuadMesh self, SoGetPrimitiveCountAction action)"},
	 { "SoQuadMesh_generateDefaultNormals", _wrap_SoQuadMesh_generateDefaultNormals, METH_VARARGS, "SoQuadMesh_generateDefaultNormals(SoQuadMesh self, SoState state, SoNormalBundle nb) -> SbBool"},
	 { "SoQuadMesh_swigregister", SoQuadMesh_swigregister, METH_O, NULL},
	 { "SoQuadMesh_swiginit", SoQuadMesh_swiginit, METH_VARARGS, NULL},
	 { "SoTriangleStripSet_getClassTypeId", _wrap_SoTriangleStripSet_getClassTypeId, METH_NOARGS, "SoTriangleStripSet_getClassTypeId() -> SoType"},
	 { "SoTriangleStripSet_getTypeId", _wrap_SoTriangleStripSet_getTypeId, METH_O, "SoTriangleStripSet_getTypeId(SoTriangleStripSet self) -> SoType"},
	 { "SoTriangleStripSet_initClass", _wrap_SoTriangleStripSet_initClass, METH_NOARGS, "SoTriangleStripSet_initClass()"},
	 { "new_SoTriangleStripSet", _wrap_new_SoTriangleStripSet, METH_NOARGS, "new_SoTriangleStripSet() -> SoTriangleStripSet"},
	 { "SoTriangleStripSet_numVertices_set", _wrap_SoTriangleStripSet_numVertices_set, METH_VARARGS, "SoTriangleStripSet_numVertices_set(SoTriangleStripSet self, SoMFInt32 numVertices)"},
	 { "SoTriangleStripSet_numVertices_get", _wrap_SoTriangleStripSet_numVertices_get, METH_O, "SoTriangleStripSet_numVertices_get(SoTriangleStripSet self) -> SoMFInt32"},
	 { "SoTriangleStripSet_GLRender", _wrap_SoTriangleStripSet_GLRender, METH_VARARGS, "SoTriangleStripSet_GLRender(SoTriangleStripSet self, SoGLRenderAction action)"},
	 { "SoTriangleStripSet_getPrimitiveCount", _wrap_SoTriangleStripSet_getPrimitiveCount, METH_VARARGS, "SoTriangleStripSet_getPrimitiveCount(SoTriangleStripSet self, SoGetPrimitiveCountAction action)"},
	 { "SoTriangleStripSet_generateDefaultNormals", _wrap_SoTriangleStripSet_generateDefaultNormals, METH_VARARGS, "SoTriangleStripSet_generateDefaultNormals(SoTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"},
	 { "SoTriangleStripSet_swigregister", SoTriangleStripSet_swigregister, METH_O, NULL},
	 { "SoTriangleStripSet_swiginit", SoTriangleStripSet_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedPointSet_getClassTypeId", _wrap_SoIndexedPointSet_getClassTypeId, METH_NOARGS, "SoIndexedPointSet_getClassTypeId() -> SoType"},
	 { "SoIndexedPointSet_getTypeId", _wrap_SoIndexedPointSet_getTypeId, METH_O, "SoIndexedPointSet_getTypeId(SoIndexedPointSet self) -> SoType"},
	 { "SoIndexedPointSet_initClass", _wrap_SoIndexedPointSet_initClass, METH_NOARGS, "SoIndexedPointSet_initClass()"},
	 { "new_SoIndexedPointSet", _wrap_new_SoIndexedPointSet, METH_NOARGS, "new_SoIndexedPointSet() -> SoIndexedPointSet"},
	 { "SoIndexedPointSet_GLRender", _wrap_SoIndexedPointSet_GLRender, METH_VARARGS, "SoIndexedPointSet_GLRender(SoIndexedPointSet self, SoGLRenderAction action)"},
	 { "SoIndexedPointSet_getBoundingBox", _wrap_SoIndexedPointSet_getBoundingBox, METH_VARARGS, "SoIndexedPointSet_getBoundingBox(SoIndexedPointSet self, SoGetBoundingBoxAction action)"},
	 { "SoIndexedPointSet_getPrimitiveCount", _wrap_SoIndexedPointSet_getPrimitiveCount, METH_VARARGS, "SoIndexedPointSet_getPrimitiveCount(SoIndexedPointSet self, SoGetPrimitiveCountAction action)"},
	 { "SoIndexedPointSet_notify", _wrap_SoIndexedPointSet_notify, METH_VARARGS, "SoIndexedPointSet_notify(SoIndexedPointSet self, SoNotList list)"},
	 { "SoIndexedPointSet_swigregister", SoIndexedPointSet_swigregister, METH_O, NULL},
	 { "SoIndexedPointSet_swiginit", SoIndexedPointSet_swiginit, METH_VARARGS, NULL},
	 { "SoIndexedMarkerSet_getClassTypeId", _wrap_SoIndexedMarkerSet_getClassTypeId, METH_NOARGS, "SoIndexedMarkerSet_getClassTypeId() -> SoType"},
	 { "SoIndexedMarkerSet_getTypeId", _wrap_SoIndexedMarkerSet_getTypeId, METH_O, "SoIndexedMarkerSet_getTypeId(SoIndexedMarkerSet self) -> SoType"},
	 { "SoIndexedMarkerSet_initClass", _wrap_SoIndexedMarkerSet_initClass, METH_NOARGS, "SoIndexedMarkerSet_initClass()"},
	 { "new_SoIndexedMarkerSet", _wrap_new_SoIndexedMarkerSet, METH_NOARGS, "new_SoIndexedMarkerSet() -> SoIndexedMarkerSet"},
	 { "SoIndexedMarkerSet_markerIndex_set", _wrap_SoIndexedMarkerSet_markerIndex_set, METH_VARARGS, "SoIndexedMarkerSet_markerIndex_set(SoIndexedMarkerSet self, SoMFInt32 markerIndex)"},
	 { "SoIndexedMarkerSet_markerIndex_get", _wrap_SoIndexedMarkerSet_markerIndex_get, METH_O, "SoIndexedMarkerSet_markerIndex_get(SoIndexedMarkerSet self) -> SoMFInt32"},
	 { "SoIndexedMarkerSet_GLRender", _wrap_SoIndexedMarkerSet_GLRender, METH_VARARGS, "SoIndexedMarkerSet_GLRender(SoIndexedMarkerSet self, SoGLRenderAction action)"},
	 { "SoIndexedMarkerSet_swigregister", SoIndexedMarkerSet_swigregister, METH_O, NULL},
	 { "SoIndexedMarkerSet_swiginit", SoIndexedMarkerSet_swiginit, METH_VARARGS, NULL},
	 { "SoNurbsCurve_getClassTypeId", _wrap_SoNurbsCurve_getClassTypeId, METH_NOARGS, "SoNurbsCurve_getClassTypeId() -> SoType"},
	 { "SoNurbsCurve_getTypeId", _wrap_SoNurbsCurve_getTypeId, METH_O, "SoNurbsCurve_getTypeId(SoNurbsCurve self) -> SoType"},
	 { "SoNurbsCurve_initClass", _wrap_SoNurbsCurve_initClass, METH_NOARGS, "SoNurbsCurve_initClass()"},
	 { "new_SoNurbsCurve", _wrap_new_SoNurbsCurve, METH_NOARGS, "new_SoNurbsCurve() -> SoNurbsCurve"},
	 { "SoNurbsCurve_numControlPoints_set", _wrap_SoNurbsCurve_numControlPoints_set, METH_VARARGS, "SoNurbsCurve_numControlPoints_set(SoNurbsCurve self, SoSFInt32 numControlPoints)"},
	 { "SoNurbsCurve_numControlPoints_get", _wrap_SoNurbsCurve_numControlPoints_get, METH_O, "SoNurbsCurve_numControlPoints_get(SoNurbsCurve self) -> SoSFInt32"},
	 { "SoNurbsCurve_knotVector_set", _wrap_SoNurbsCurve_knotVector_set, METH_VARARGS, "SoNurbsCurve_knotVector_set(SoNurbsCurve self, SoMFFloat knotVector)"},
	 { "SoNurbsCurve_knotVector_get", _wrap_SoNurbsCurve_knotVector_get, METH_O, "SoNurbsCurve_knotVector_get(SoNurbsCurve self) -> SoMFFloat"},
	 { "SoNurbsCurve_GLRender", _wrap_SoNurbsCurve_GLRender, METH_VARARGS, "SoNurbsCurve_GLRender(SoNurbsCurve self, SoGLRenderAction action)"},
	 { "SoNurbsCurve_rayPick", _wrap_SoNurbsCurve_rayPick, METH_VARARGS, "SoNurbsCurve_rayPick(SoNurbsCurve self, SoRayPickAction action)"},
	 { "SoNurbsCurve_getPrimitiveCount", _wrap_SoNurbsCurve_getPrimitiveCount, METH_VARARGS, "SoNurbsCurve_getPrimitiveCount(SoNurbsCurve self, SoGetPrimitiveCountAction action)"},
	 { "SoNurbsCurve_getBoundingBox", _wrap_SoNurbsCurve_getBoundingBox, METH_VARARGS, "SoNurbsCurve_getBoundingBox(SoNurbsCurve self, SoGetBoundingBoxAction action)"},
	 { "SoNurbsCurve_sendPrimitive", _wrap_SoNurbsCurve_sendPrimitive, METH_VARARGS, "SoNurbsCurve_sendPrimitive(SoNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"},
	 { "SoNurbsCurve_swigregister", SoNurbsCurve_swigregister, METH_O, NULL},
	 { "SoNurbsCurve_swiginit", SoNurbsCurve_swiginit, METH_VARARGS, NULL},
	 { "SoNurbsSurface_getClassTypeId", _wrap_SoNurbsSurface_getClassTypeId, METH_NOARGS, "SoNurbsSurface_getClassTypeId() -> SoType"},
	 { "SoNurbsSurface_getTypeId", _wrap_SoNurbsSurface_getTypeId, METH_O, "SoNurbsSurface_getTypeId(SoNurbsSurface self) -> SoType"},
	 { "SoNurbsSurface_initClass", _wrap_SoNurbsSurface_initClass, METH_NOARGS, "SoNurbsSurface_initClass()"},
	 { "new_SoNurbsSurface", _wrap_new_SoNurbsSurface, METH_NOARGS, "new_SoNurbsSurface() -> SoNurbsSurface"},
	 { "SoNurbsSurface_numUControlPoints_set", _wrap_SoNurbsSurface_numUControlPoints_set, METH_VARARGS, "SoNurbsSurface_numUControlPoints_set(SoNurbsSurface self, SoSFInt32 numUControlPoints)"},
	 { "SoNurbsSurface_numUControlPoints_get", _wrap_SoNurbsSurface_numUControlPoints_get, METH_O, "SoNurbsSurface_numUControlPoints_get(SoNurbsSurface self) -> SoSFInt32"},
	 { "SoNurbsSurface_numVControlPoints_set", _wrap_SoNurbsSurface_numVControlPoints_set, METH_VARARGS, "SoNurbsSurface_numVControlPoints_set(SoNurbsSurface self, SoSFInt32 numVControlPoints)"},
	 { "SoNurbsSurface_numVControlPoints_get", _wrap_SoNurbsSurface_numVControlPoints_get, METH_O, "SoNurbsSurface_numVControlPoints_get(SoNurbsSurface self) -> SoSFInt32"},
	 { "SoNurbsSurface_numSControlPoints_set", _wrap_SoNurbsSurface_numSControlPoints_set, METH_VARARGS, "SoNurbsSurface_numSControlPoints_set(SoNurbsSurface self, SoSFInt32 numSControlPoints)"},
	 { "SoNurbsSurface_numSControlPoints_get", _wrap_SoNurbsSurface_numSControlPoints_get, METH_O, "SoNurbsSurface_numSControlPoints_get(SoNurbsSurface self) -> SoSFInt32"},
	 { "SoNurbsSurface_numTControlPoints_set", _wrap_SoNurbsSurface_numTControlPoints_set, METH_VARARGS, "SoNurbsSurface_numTControlPoints_set(SoNurbsSurface self, SoSFInt32 numTControlPoints)"},
	 { "SoNurbsSurface_numTControlPoints_get", _wrap_SoNurbsSurface_numTControlPoints_get, METH_O, "SoNurbsSurface_numTControlPoints_get(SoNurbsSurface self) -> SoSFInt32"},
	 { "SoNurbsSurface_uKnotVector_set", _wrap_SoNurbsSurface_uKnotVector_set, METH_VARARGS, "SoNurbsSurface_uKnotVector_set(SoNurbsSurface self, SoMFFloat uKnotVector)"},
	 { "SoNurbsSurface_uKnotVector_get", _wrap_SoNurbsSurface_uKnotVector_get, METH_O, "SoNurbsSurface_uKnotVector_get(SoNurbsSurface self) -> SoMFFloat"},
	 { "SoNurbsSurface_vKnotVector_set", _wrap_SoNurbsSurface_vKnotVector_set, METH_VARARGS, "SoNurbsSurface_vKnotVector_set(SoNurbsSurface self, SoMFFloat vKnotVector)"},
	 { "SoNurbsSurface_vKnotVector_get", _wrap_SoNurbsSurface_vKnotVector_get, METH_O, "SoNurbsSurface_vKnotVector_get(SoNurbsSurface self) -> SoMFFloat"},
	 { "SoNurbsSurface_sKnotVector_set", _wrap_SoNurbsSurface_sKnotVector_set, METH_VARARGS, "SoNurbsSurface_sKnotVector_set(SoNurbsSurface self, SoMFFloat sKnotVector)"},
	 { "SoNurbsSurface_sKnotVector_get", _wrap_SoNurbsSurface_sKnotVector_get, METH_O, "SoNurbsSurface_sKnotVector_get(SoNurbsSurface self) -> SoMFFloat"},
	 { "SoNurbsSurface_tKnotVector_set", _wrap_SoNurbsSurface_tKnotVector_set, METH_VARARGS, "SoNurbsSurface_tKnotVector_set(SoNurbsSurface self, SoMFFloat tKnotVector)"},
	 { "SoNurbsSurface_tKnotVector_get", _wrap_SoNurbsSurface_tKnotVector_get, METH_O, "SoNurbsSurface_tKnotVector_get(SoNurbsSurface self) -> SoMFFloat"},
	 { "SoNurbsSurface_GLRender", _wrap_SoNurbsSurface_GLRender, METH_VARARGS, "SoNurbsSurface_GLRender(SoNurbsSurface self, SoGLRenderAction action)"},
	 { "SoNurbsSurface_rayPick", _wrap_SoNurbsSurface_rayPick, METH_VARARGS, "SoNurbsSurface_rayPick(SoNurbsSurface self, SoRayPickAction action)"},
	 { "SoNurbsSurface_getPrimitiveCount", _wrap_SoNurbsSurface_getPrimitiveCount, METH_VARARGS, "SoNurbsSurface_getPrimitiveCount(SoNurbsSurface self, SoGetPrimitiveCountAction action)"},
	 { "SoNurbsSurface_sendPrimitive", _wrap_SoNurbsSurface_sendPrimitive, METH_VARARGS, "SoNurbsSurface_sendPrimitive(SoNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"},
	 { "SoNurbsSurface_swigregister", SoNurbsSurface_swigregister, METH_O, NULL},
	 { "SoNurbsSurface_swiginit", SoNurbsSurface_swiginit, METH_VARARGS, NULL},
	 { "SoSphere_getClassTypeId", _wrap_SoSphere_getClassTypeId, METH_NOARGS, "SoSphere_getClassTypeId() -> SoType"},
	 { "SoSphere_getTypeId", _wrap_SoSphere_getTypeId, METH_O, "SoSphere_getTypeId(SoSphere self) -> SoType"},
	 { "SoSphere_initClass", _wrap_SoSphere_initClass, METH_NOARGS, "SoSphere_initClass()"},
	 { "new_SoSphere", _wrap_new_SoSphere, METH_NOARGS, "new_SoSphere() -> SoSphere"},
	 { "SoSphere_radius_set", _wrap_SoSphere_radius_set, METH_VARARGS, "SoSphere_radius_set(SoSphere self, SoSFFloat radius)"},
	 { "SoSphere_radius_get", _wrap_SoSphere_radius_get, METH_O, "SoSphere_radius_get(SoSphere self) -> SoSFFloat"},
	 { "SoSphere_GLRender", _wrap_SoSphere_GLRender, METH_VARARGS, "SoSphere_GLRender(SoSphere self, SoGLRenderAction action)"},
	 { "SoSphere_rayPick", _wrap_SoSphere_rayPick, METH_VARARGS, "SoSphere_rayPick(SoSphere self, SoRayPickAction action)"},
	 { "SoSphere_getPrimitiveCount", _wrap_SoSphere_getPrimitiveCount, METH_VARARGS, "SoSphere_getPrimitiveCount(SoSphere self, SoGetPrimitiveCountAction action)"},
	 { "SoSphere_swigregister", SoSphere_swigregister, METH_O, NULL},
	 { "SoSphere_swiginit", SoSphere_swiginit, METH_VARARGS, NULL},
	 { "SoText2_getClassTypeId", _wrap_SoText2_getClassTypeId, METH_NOARGS, "SoText2_getClassTypeId() -> SoType"},
	 { "SoText2_getTypeId", _wrap_SoText2_getTypeId, METH_O, "SoText2_getTypeId(SoText2 self) -> SoType"},
	 { "SoText2_initClass", _wrap_SoText2_initClass, METH_NOARGS, "SoText2_initClass()"},
	 { "new_SoText2", _wrap_new_SoText2, METH_NOARGS, "new_SoText2() -> SoText2"},
	 { "SoText2_string_set", _wrap_SoText2_string_set, METH_VARARGS, "SoText2_string_set(SoText2 self, SoMFString string)"},
	 { "SoText2_string_get", _wrap_SoText2_string_get, METH_O, "SoText2_string_get(SoText2 self) -> SoMFString"},
	 { "SoText2_spacing_set", _wrap_SoText2_spacing_set, METH_VARARGS, "SoText2_spacing_set(SoText2 self, SoSFFloat spacing)"},
	 { "SoText2_spacing_get", _wrap_SoText2_spacing_get, METH_O, "SoText2_spacing_get(SoText2 self) -> SoSFFloat"},
	 { "SoText2_justification_set", _wrap_SoText2_justification_set, METH_VARARGS, "SoText2_justification_set(SoText2 self, SoSFEnum justification)"},
	 { "SoText2_justification_get", _wrap_SoText2_justification_get, METH_O, "SoText2_justification_get(SoText2 self) -> SoSFEnum"},
	 { "SoText2_GLRender", _wrap_SoText2_GLRender, METH_VARARGS, "SoText2_GLRender(SoText2 self, SoGLRenderAction action)"},
	 { "SoText2_rayPick", _wrap_SoText2_rayPick, METH_VARARGS, "SoText2_rayPick(SoText2 self, SoRayPickAction action)"},
	 { "SoText2_getPrimitiveCount", _wrap_SoText2_getPrimitiveCount, METH_VARARGS, "SoText2_getPrimitiveCount(SoText2 self, SoGetPrimitiveCountAction action)"},
	 { "SoText2_swigregister", SoText2_swigregister, METH_O, NULL},
	 { "SoText2_swiginit", SoText2_swiginit, METH_VARARGS, NULL},
	 { "SoText3_getClassTypeId", _wrap_SoText3_getClassTypeId, METH_NOARGS, "SoText3_getClassTypeId() -> SoType"},
	 { "SoText3_getTypeId", _wrap_SoText3_getTypeId, METH_O, "SoText3_getTypeId(SoText3 self) -> SoType"},
	 { "SoText3_initClass", _wrap_SoText3_initClass, METH_NOARGS, "SoText3_initClass()"},
	 { "new_SoText3", _wrap_new_SoText3, METH_NOARGS, "new_SoText3() -> SoText3"},
	 { "SoText3_string_set", _wrap_SoText3_string_set, METH_VARARGS, "SoText3_string_set(SoText3 self, SoMFString string)"},
	 { "SoText3_string_get", _wrap_SoText3_string_get, METH_O, "SoText3_string_get(SoText3 self) -> SoMFString"},
	 { "SoText3_spacing_set", _wrap_SoText3_spacing_set, METH_VARARGS, "SoText3_spacing_set(SoText3 self, SoSFFloat spacing)"},
	 { "SoText3_spacing_get", _wrap_SoText3_spacing_get, METH_O, "SoText3_spacing_get(SoText3 self) -> SoSFFloat"},
	 { "SoText3_justification_set", _wrap_SoText3_justification_set, METH_VARARGS, "SoText3_justification_set(SoText3 self, SoSFEnum justification)"},
	 { "SoText3_justification_get", _wrap_SoText3_justification_get, METH_O, "SoText3_justification_get(SoText3 self) -> SoSFEnum"},
	 { "SoText3_parts_set", _wrap_SoText3_parts_set, METH_VARARGS, "SoText3_parts_set(SoText3 self, SoSFBitMask parts)"},
	 { "SoText3_parts_get", _wrap_SoText3_parts_get, METH_O, "SoText3_parts_get(SoText3 self) -> SoSFBitMask"},
	 { "SoText3_getCharacterBounds", _wrap_SoText3_getCharacterBounds, METH_VARARGS, "SoText3_getCharacterBounds(SoText3 self, SoState state, int stringindex, int charindex) -> SbBox3f"},
	 { "SoText3_GLRender", _wrap_SoText3_GLRender, METH_VARARGS, "SoText3_GLRender(SoText3 self, SoGLRenderAction action)"},
	 { "SoText3_getPrimitiveCount", _wrap_SoText3_getPrimitiveCount, METH_VARARGS, "SoText3_getPrimitiveCount(SoText3 self, SoGetPrimitiveCountAction action)"},
	 { "SoText3_swigregister", SoText3_swigregister, METH_O, NULL},
	 { "SoText3_swiginit", SoText3_swiginit, METH_VARARGS, NULL},
	 { "SoWWWAnchor_getClassTypeId", _wrap_SoWWWAnchor_getClassTypeId, METH_NOARGS, "SoWWWAnchor_getClassTypeId() -> SoType"},
	 { "SoWWWAnchor_getTypeId", _wrap_SoWWWAnchor_getTypeId, METH_O, "SoWWWAnchor_getTypeId(SoWWWAnchor self) -> SoType"},
	 { "SoWWWAnchor_initClass", _wrap_SoWWWAnchor_initClass, METH_NOARGS, "SoWWWAnchor_initClass()"},
	 { "new_SoWWWAnchor", _wrap_new_SoWWWAnchor, METH_NOARGS, "new_SoWWWAnchor() -> SoWWWAnchor"},
	 { "SoWWWAnchor_name_set", _wrap_SoWWWAnchor_name_set, METH_VARARGS, "SoWWWAnchor_name_set(SoWWWAnchor self, SoSFString name)"},
	 { "SoWWWAnchor_name_get", _wrap_SoWWWAnchor_name_get, METH_O, "SoWWWAnchor_name_get(SoWWWAnchor self) -> SoSFString"},
	 { "SoWWWAnchor_description_set", _wrap_SoWWWAnchor_description_set, METH_VARARGS, "SoWWWAnchor_description_set(SoWWWAnchor self, SoSFString description)"},
	 { "SoWWWAnchor_description_get", _wrap_SoWWWAnchor_description_get, METH_O, "SoWWWAnchor_description_get(SoWWWAnchor self) -> SoSFString"},
	 { "SoWWWAnchor_map_set", _wrap_SoWWWAnchor_map_set, METH_VARARGS, "SoWWWAnchor_map_set(SoWWWAnchor self, SoSFEnum map)"},
	 { "SoWWWAnchor_map_get", _wrap_SoWWWAnchor_map_get, METH_O, "SoWWWAnchor_map_get(SoWWWAnchor self) -> SoSFEnum"},
	 { "SoWWWAnchor_setFullURLName", _wrap_SoWWWAnchor_setFullURLName, METH_VARARGS, "SoWWWAnchor_setFullURLName(SoWWWAnchor self, SbString url)"},
	 { "SoWWWAnchor_getFullURLName", _wrap_SoWWWAnchor_getFullURLName, METH_O, "SoWWWAnchor_getFullURLName(SoWWWAnchor self) -> SbString"},
	 { "SoWWWAnchor_handleEvent", _wrap_SoWWWAnchor_handleEvent, METH_VARARGS, "SoWWWAnchor_handleEvent(SoWWWAnchor self, SoHandleEventAction action)"},
	 { "SoWWWAnchor_setFetchURLCallBack", _wrap_SoWWWAnchor_setFetchURLCallBack, METH_VARARGS, "SoWWWAnchor_setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"},
	 { "SoWWWAnchor_setHighlightURLCallBack", _wrap_SoWWWAnchor_setHighlightURLCallBack, METH_VARARGS, "SoWWWAnchor_setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"},
	 { "SoWWWAnchor_swigregister", SoWWWAnchor_swigregister, METH_O, NULL},
	 { "SoWWWAnchor_swiginit", SoWWWAnchor_swiginit, METH_VARARGS, NULL},
	 { "SoPathSwitch_getClassTypeId", _wrap_SoPathSwitch_getClassTypeId, METH_NOARGS, "SoPathSwitch_getClassTypeId() -> SoType"},
	 { "SoPathSwitch_getTypeId", _wrap_SoPathSwitch_getTypeId, METH_O, "SoPathSwitch_getTypeId(SoPathSwitch self) -> SoType"},
	 { "SoPathSwitch_initClass", _wrap_SoPathSwitch_initClass, METH_NOARGS, "SoPathSwitch_initClass()"},
	 { "new_SoPathSwitch", _wrap_new_SoPathSwitch, METH_VARARGS, "\n"
		"SoPathSwitch()\n"
		"new_SoPathSwitch(int numchildren) -> SoPathSwitch\n"
		""},
	 { "SoPathSwitch_path_set", _wrap_SoPathSwitch_path_set, METH_VARARGS, "SoPathSwitch_path_set(SoPathSwitch self, SoSFPath path)"},
	 { "SoPathSwitch_path_get", _wrap_SoPathSwitch_path_get, METH_O, "SoPathSwitch_path_get(SoPathSwitch self) -> SoSFPath"},
	 { "SoPathSwitch_doAction", _wrap_SoPathSwitch_doAction, METH_VARARGS, "SoPathSwitch_doAction(SoPathSwitch self, SoAction action)"},
	 { "SoPathSwitch_GLRender", _wrap_SoPathSwitch_GLRender, METH_VARARGS, "SoPathSwitch_GLRender(SoPathSwitch self, SoGLRenderAction action)"},
	 { "SoPathSwitch_pick", _wrap_SoPathSwitch_pick, METH_VARARGS, "SoPathSwitch_pick(SoPathSwitch self, SoPickAction action)"},
	 { "SoPathSwitch_getBoundingBox", _wrap_SoPathSwitch_getBoundingBox, METH_VARARGS, "SoPathSwitch_getBoundingBox(SoPathSwitch self, SoGetBoundingBoxAction action)"},
	 { "SoPathSwitch_handleEvent", _wrap_SoPathSwitch_handleEvent, METH_VARARGS, "SoPathSwitch_handleEvent(SoPathSwitch self, SoHandleEventAction action)"},
	 { "SoPathSwitch_getMatrix", _wrap_SoPathSwitch_getMatrix, METH_VARARGS, "SoPathSwitch_getMatrix(SoPathSwitch self, SoGetMatrixAction action)"},
	 { "SoPathSwitch_search", _wrap_SoPathSwitch_search, METH_VARARGS, "SoPathSwitch_search(SoPathSwitch self, SoSearchAction action)"},
	 { "SoPathSwitch_callback", _wrap_SoPathSwitch_callback, METH_VARARGS, "SoPathSwitch_callback(SoPathSwitch self, SoCallbackAction action)"},
	 { "SoPathSwitch_getPrimitiveCount", _wrap_SoPathSwitch_getPrimitiveCount, METH_VARARGS, "SoPathSwitch_getPrimitiveCount(SoPathSwitch self, SoGetPrimitiveCountAction action)"},
	 { "SoPathSwitch_audioRender", _wrap_SoPathSwitch_audioRender, METH_VARARGS, "SoPathSwitch_audioRender(SoPathSwitch self, SoAudioRenderAction action)"},
	 { "SoPathSwitch_swigregister", SoPathSwitch_swigregister, METH_O, NULL},
	 { "SoPathSwitch_swiginit", SoPathSwitch_swiginit, METH_VARARGS, NULL},
	 { "SoTransformSeparator_getClassTypeId", _wrap_SoTransformSeparator_getClassTypeId, METH_NOARGS, "SoTransformSeparator_getClassTypeId() -> SoType"},
	 { "SoTransformSeparator_getTypeId", _wrap_SoTransformSeparator_getTypeId, METH_O, "SoTransformSeparator_getTypeId(SoTransformSeparator self) -> SoType"},
	 { "SoTransformSeparator_initClass", _wrap_SoTransformSeparator_initClass, METH_NOARGS, "SoTransformSeparator_initClass()"},
	 { "new_SoTransformSeparator", _wrap_new_SoTransformSeparator, METH_VARARGS, "\n"
		"SoTransformSeparator()\n"
		"new_SoTransformSeparator(int nChildren) -> SoTransformSeparator\n"
		""},
	 { "SoTransformSeparator_doAction", _wrap_SoTransformSeparator_doAction, METH_VARARGS, "SoTransformSeparator_doAction(SoTransformSeparator self, SoAction action)"},
	 { "SoTransformSeparator_callback", _wrap_SoTransformSeparator_callback, METH_VARARGS, "SoTransformSeparator_callback(SoTransformSeparator self, SoCallbackAction action)"},
	 { "SoTransformSeparator_GLRender", _wrap_SoTransformSeparator_GLRender, METH_VARARGS, "SoTransformSeparator_GLRender(SoTransformSeparator self, SoGLRenderAction action)"},
	 { "SoTransformSeparator_pick", _wrap_SoTransformSeparator_pick, METH_VARARGS, "SoTransformSeparator_pick(SoTransformSeparator self, SoPickAction action)"},
	 { "SoTransformSeparator_getBoundingBox", _wrap_SoTransformSeparator_getBoundingBox, METH_VARARGS, "SoTransformSeparator_getBoundingBox(SoTransformSeparator self, SoGetBoundingBoxAction action)"},
	 { "SoTransformSeparator_getMatrix", _wrap_SoTransformSeparator_getMatrix, METH_VARARGS, "SoTransformSeparator_getMatrix(SoTransformSeparator self, SoGetMatrixAction action)"},
	 { "SoTransformSeparator_getPrimitiveCount", _wrap_SoTransformSeparator_getPrimitiveCount, METH_VARARGS, "SoTransformSeparator_getPrimitiveCount(SoTransformSeparator self, SoGetPrimitiveCountAction action)"},
	 { "SoTransformSeparator_audioRender", _wrap_SoTransformSeparator_audioRender, METH_VARARGS, "SoTransformSeparator_audioRender(SoTransformSeparator self, SoAudioRenderAction action)"},
	 { "SoTransformSeparator_swigregister", SoTransformSeparator_swigregister, METH_O, NULL},
	 { "SoTransformSeparator_swiginit", SoTransformSeparator_swiginit, METH_VARARGS, NULL},
	 { "SoRotation_getClassTypeId", _wrap_SoRotation_getClassTypeId, METH_NOARGS, "SoRotation_getClassTypeId() -> SoType"},
	 { "SoRotation_getTypeId", _wrap_SoRotation_getTypeId, METH_O, "SoRotation_getTypeId(SoRotation self) -> SoType"},
	 { "SoRotation_initClass", _wrap_SoRotation_initClass, METH_NOARGS, "SoRotation_initClass()"},
	 { "new_SoRotation", _wrap_new_SoRotation, METH_NOARGS, "new_SoRotation() -> SoRotation"},
	 { "SoRotation_rotation_set", _wrap_SoRotation_rotation_set, METH_VARARGS, "SoRotation_rotation_set(SoRotation self, SoSFRotation rotation)"},
	 { "SoRotation_rotation_get", _wrap_SoRotation_rotation_get, METH_O, "SoRotation_rotation_get(SoRotation self) -> SoSFRotation"},
	 { "SoRotation_doAction", _wrap_SoRotation_doAction, METH_VARARGS, "SoRotation_doAction(SoRotation self, SoAction action)"},
	 { "SoRotation_GLRender", _wrap_SoRotation_GLRender, METH_VARARGS, "SoRotation_GLRender(SoRotation self, SoGLRenderAction action)"},
	 { "SoRotation_callback", _wrap_SoRotation_callback, METH_VARARGS, "SoRotation_callback(SoRotation self, SoCallbackAction action)"},
	 { "SoRotation_getBoundingBox", _wrap_SoRotation_getBoundingBox, METH_VARARGS, "SoRotation_getBoundingBox(SoRotation self, SoGetBoundingBoxAction action)"},
	 { "SoRotation_getMatrix", _wrap_SoRotation_getMatrix, METH_VARARGS, "SoRotation_getMatrix(SoRotation self, SoGetMatrixAction action)"},
	 { "SoRotation_pick", _wrap_SoRotation_pick, METH_VARARGS, "SoRotation_pick(SoRotation self, SoPickAction action)"},
	 { "SoRotation_getPrimitiveCount", _wrap_SoRotation_getPrimitiveCount, METH_VARARGS, "SoRotation_getPrimitiveCount(SoRotation self, SoGetPrimitiveCountAction action)"},
	 { "SoRotation_swigregister", SoRotation_swigregister, METH_O, NULL},
	 { "SoRotation_swiginit", SoRotation_swiginit, METH_VARARGS, NULL},
	 { "SoPendulum_getClassTypeId", _wrap_SoPendulum_getClassTypeId, METH_NOARGS, "SoPendulum_getClassTypeId() -> SoType"},
	 { "SoPendulum_getTypeId", _wrap_SoPendulum_getTypeId, METH_O, "SoPendulum_getTypeId(SoPendulum self) -> SoType"},
	 { "SoPendulum_initClass", _wrap_SoPendulum_initClass, METH_NOARGS, "SoPendulum_initClass()"},
	 { "new_SoPendulum", _wrap_new_SoPendulum, METH_NOARGS, "new_SoPendulum() -> SoPendulum"},
	 { "SoPendulum_rotation0_set", _wrap_SoPendulum_rotation0_set, METH_VARARGS, "SoPendulum_rotation0_set(SoPendulum self, SoSFRotation rotation0)"},
	 { "SoPendulum_rotation0_get", _wrap_SoPendulum_rotation0_get, METH_O, "SoPendulum_rotation0_get(SoPendulum self) -> SoSFRotation"},
	 { "SoPendulum_rotation1_set", _wrap_SoPendulum_rotation1_set, METH_VARARGS, "SoPendulum_rotation1_set(SoPendulum self, SoSFRotation rotation1)"},
	 { "SoPendulum_rotation1_get", _wrap_SoPendulum_rotation1_get, METH_O, "SoPendulum_rotation1_get(SoPendulum self) -> SoSFRotation"},
	 { "SoPendulum_speed_set", _wrap_SoPendulum_speed_set, METH_VARARGS, "SoPendulum_speed_set(SoPendulum self, SoSFFloat speed)"},
	 { "SoPendulum_speed_get", _wrap_SoPendulum_speed_get, METH_O, "SoPendulum_speed_get(SoPendulum self) -> SoSFFloat"},
	 { "SoPendulum_on_set", _wrap_SoPendulum_on_set, METH_VARARGS, "SoPendulum_on_set(SoPendulum self, SoSFBool on)"},
	 { "SoPendulum_on_get", _wrap_SoPendulum_on_get, METH_O, "SoPendulum_on_get(SoPendulum self) -> SoSFBool"},
	 { "SoPendulum_write", _wrap_SoPendulum_write, METH_VARARGS, "SoPendulum_write(SoPendulum self, SoWriteAction action)"},
	 { "SoPendulum_swigregister", SoPendulum_swigregister, METH_O, NULL},
	 { "SoPendulum_swiginit", SoPendulum_swiginit, METH_VARARGS, NULL},
	 { "SoRotor_getClassTypeId", _wrap_SoRotor_getClassTypeId, METH_NOARGS, "SoRotor_getClassTypeId() -> SoType"},
	 { "SoRotor_getTypeId", _wrap_SoRotor_getTypeId, METH_O, "SoRotor_getTypeId(SoRotor self) -> SoType"},
	 { "SoRotor_initClass", _wrap_SoRotor_initClass, METH_NOARGS, "SoRotor_initClass()"},
	 { "new_SoRotor", _wrap_new_SoRotor, METH_NOARGS, "new_SoRotor() -> SoRotor"},
	 { "SoRotor_speed_set", _wrap_SoRotor_speed_set, METH_VARARGS, "SoRotor_speed_set(SoRotor self, SoSFFloat speed)"},
	 { "SoRotor_speed_get", _wrap_SoRotor_speed_get, METH_O, "SoRotor_speed_get(SoRotor self) -> SoSFFloat"},
	 { "SoRotor_on_set", _wrap_SoRotor_on_set, METH_VARARGS, "SoRotor_on_set(SoRotor self, SoSFBool on)"},
	 { "SoRotor_on_get", _wrap_SoRotor_on_get, METH_O, "SoRotor_on_get(SoRotor self) -> SoSFBool"},
	 { "SoRotor_swigregister", SoRotor_swigregister, METH_O, NULL},
	 { "SoRotor_swiginit", SoRotor_swiginit, METH_VARARGS, NULL},
	 { "SoResetTransform_getClassTypeId", _wrap_SoResetTransform_getClassTypeId, METH_NOARGS, "SoResetTransform_getClassTypeId() -> SoType"},
	 { "SoResetTransform_getTypeId", _wrap_SoResetTransform_getTypeId, METH_O, "SoResetTransform_getTypeId(SoResetTransform self) -> SoType"},
	 { "SoResetTransform_initClass", _wrap_SoResetTransform_initClass, METH_NOARGS, "SoResetTransform_initClass()"},
	 { "new_SoResetTransform", _wrap_new_SoResetTransform, METH_NOARGS, "new_SoResetTransform() -> SoResetTransform"},
	 { "SoResetTransform_whatToReset_set", _wrap_SoResetTransform_whatToReset_set, METH_VARARGS, "SoResetTransform_whatToReset_set(SoResetTransform self, SoSFBitMask whatToReset)"},
	 { "SoResetTransform_whatToReset_get", _wrap_SoResetTransform_whatToReset_get, METH_O, "SoResetTransform_whatToReset_get(SoResetTransform self) -> SoSFBitMask"},
	 { "SoResetTransform_doAction", _wrap_SoResetTransform_doAction, METH_VARARGS, "SoResetTransform_doAction(SoResetTransform self, SoAction action)"},
	 { "SoResetTransform_callback", _wrap_SoResetTransform_callback, METH_VARARGS, "SoResetTransform_callback(SoResetTransform self, SoCallbackAction action)"},
	 { "SoResetTransform_GLRender", _wrap_SoResetTransform_GLRender, METH_VARARGS, "SoResetTransform_GLRender(SoResetTransform self, SoGLRenderAction action)"},
	 { "SoResetTransform_getBoundingBox", _wrap_SoResetTransform_getBoundingBox, METH_VARARGS, "SoResetTransform_getBoundingBox(SoResetTransform self, SoGetBoundingBoxAction action)"},
	 { "SoResetTransform_getMatrix", _wrap_SoResetTransform_getMatrix, METH_VARARGS, "SoResetTransform_getMatrix(SoResetTransform self, SoGetMatrixAction action)"},
	 { "SoResetTransform_pick", _wrap_SoResetTransform_pick, METH_VARARGS, "SoResetTransform_pick(SoResetTransform self, SoPickAction action)"},
	 { "SoResetTransform_getPrimitiveCount", _wrap_SoResetTransform_getPrimitiveCount, METH_VARARGS, "SoResetTransform_getPrimitiveCount(SoResetTransform self, SoGetPrimitiveCountAction action)"},
	 { "SoResetTransform_swigregister", SoResetTransform_swigregister, METH_O, NULL},
	 { "SoResetTransform_swiginit", SoResetTransform_swiginit, METH_VARARGS, NULL},
	 { "SoRotationXYZ_getClassTypeId", _wrap_SoRotationXYZ_getClassTypeId, METH_NOARGS, "SoRotationXYZ_getClassTypeId() -> SoType"},
	 { "SoRotationXYZ_getTypeId", _wrap_SoRotationXYZ_getTypeId, METH_O, "SoRotationXYZ_getTypeId(SoRotationXYZ self) -> SoType"},
	 { "SoRotationXYZ_initClass", _wrap_SoRotationXYZ_initClass, METH_NOARGS, "SoRotationXYZ_initClass()"},
	 { "new_SoRotationXYZ", _wrap_new_SoRotationXYZ, METH_NOARGS, "new_SoRotationXYZ() -> SoRotationXYZ"},
	 { "SoRotationXYZ_axis_set", _wrap_SoRotationXYZ_axis_set, METH_VARARGS, "SoRotationXYZ_axis_set(SoRotationXYZ self, SoSFEnum axis)"},
	 { "SoRotationXYZ_axis_get", _wrap_SoRotationXYZ_axis_get, METH_O, "SoRotationXYZ_axis_get(SoRotationXYZ self) -> SoSFEnum"},
	 { "SoRotationXYZ_angle_set", _wrap_SoRotationXYZ_angle_set, METH_VARARGS, "SoRotationXYZ_angle_set(SoRotationXYZ self, SoSFFloat angle)"},
	 { "SoRotationXYZ_angle_get", _wrap_SoRotationXYZ_angle_get, METH_O, "SoRotationXYZ_angle_get(SoRotationXYZ self) -> SoSFFloat"},
	 { "SoRotationXYZ_getRotation", _wrap_SoRotationXYZ_getRotation, METH_O, "SoRotationXYZ_getRotation(SoRotationXYZ self) -> SbRotation"},
	 { "SoRotationXYZ_doAction", _wrap_SoRotationXYZ_doAction, METH_VARARGS, "SoRotationXYZ_doAction(SoRotationXYZ self, SoAction action)"},
	 { "SoRotationXYZ_GLRender", _wrap_SoRotationXYZ_GLRender, METH_VARARGS, "SoRotationXYZ_GLRender(SoRotationXYZ self, SoGLRenderAction action)"},
	 { "SoRotationXYZ_callback", _wrap_SoRotationXYZ_callback, METH_VARARGS, "SoRotationXYZ_callback(SoRotationXYZ self, SoCallbackAction action)"},
	 { "SoRotationXYZ_getBoundingBox", _wrap_SoRotationXYZ_getBoundingBox, METH_VARARGS, "SoRotationXYZ_getBoundingBox(SoRotationXYZ self, SoGetBoundingBoxAction action)"},
	 { "SoRotationXYZ_getMatrix", _wrap_SoRotationXYZ_getMatrix, METH_VARARGS, "SoRotationXYZ_getMatrix(SoRotationXYZ self, SoGetMatrixAction action)"},
	 { "SoRotationXYZ_pick", _wrap_SoRotationXYZ_pick, METH_VARARGS, "SoRotationXYZ_pick(SoRotationXYZ self, SoPickAction action)"},
	 { "SoRotationXYZ_getPrimitiveCount", _wrap_SoRotationXYZ_getPrimitiveCount, METH_VARARGS, "SoRotationXYZ_getPrimitiveCount(SoRotationXYZ self, SoGetPrimitiveCountAction action)"},
	 { "SoRotationXYZ_swigregister", SoRotationXYZ_swigregister, METH_O, NULL},
	 { "SoRotationXYZ_swiginit", SoRotationXYZ_swiginit, METH_VARARGS, NULL},
	 { "SoTranslation_getClassTypeId", _wrap_SoTranslation_getClassTypeId, METH_NOARGS, "SoTranslation_getClassTypeId() -> SoType"},
	 { "SoTranslation_getTypeId", _wrap_SoTranslation_getTypeId, METH_O, "SoTranslation_getTypeId(SoTranslation self) -> SoType"},
	 { "SoTranslation_initClass", _wrap_SoTranslation_initClass, METH_NOARGS, "SoTranslation_initClass()"},
	 { "new_SoTranslation", _wrap_new_SoTranslation, METH_NOARGS, "new_SoTranslation() -> SoTranslation"},
	 { "SoTranslation_translation_set", _wrap_SoTranslation_translation_set, METH_VARARGS, "SoTranslation_translation_set(SoTranslation self, SoSFVec3f translation)"},
	 { "SoTranslation_translation_get", _wrap_SoTranslation_translation_get, METH_O, "SoTranslation_translation_get(SoTranslation self) -> SoSFVec3f"},
	 { "SoTranslation_doAction", _wrap_SoTranslation_doAction, METH_VARARGS, "SoTranslation_doAction(SoTranslation self, SoAction action)"},
	 { "SoTranslation_callback", _wrap_SoTranslation_callback, METH_VARARGS, "SoTranslation_callback(SoTranslation self, SoCallbackAction action)"},
	 { "SoTranslation_GLRender", _wrap_SoTranslation_GLRender, METH_VARARGS, "SoTranslation_GLRender(SoTranslation self, SoGLRenderAction action)"},
	 { "SoTranslation_getBoundingBox", _wrap_SoTranslation_getBoundingBox, METH_VARARGS, "SoTranslation_getBoundingBox(SoTranslation self, SoGetBoundingBoxAction action)"},
	 { "SoTranslation_getMatrix", _wrap_SoTranslation_getMatrix, METH_VARARGS, "SoTranslation_getMatrix(SoTranslation self, SoGetMatrixAction action)"},
	 { "SoTranslation_pick", _wrap_SoTranslation_pick, METH_VARARGS, "SoTranslation_pick(SoTranslation self, SoPickAction action)"},
	 { "SoTranslation_getPrimitiveCount", _wrap_SoTranslation_getPrimitiveCount, METH_VARARGS, "SoTranslation_getPrimitiveCount(SoTranslation self, SoGetPrimitiveCountAction action)"},
	 { "SoTranslation_swigregister", SoTranslation_swigregister, METH_O, NULL},
	 { "SoTranslation_swiginit", SoTranslation_swiginit, METH_VARARGS, NULL},
	 { "SoShuttle_getClassTypeId", _wrap_SoShuttle_getClassTypeId, METH_NOARGS, "SoShuttle_getClassTypeId() -> SoType"},
	 { "SoShuttle_getTypeId", _wrap_SoShuttle_getTypeId, METH_O, "SoShuttle_getTypeId(SoShuttle self) -> SoType"},
	 { "SoShuttle_initClass", _wrap_SoShuttle_initClass, METH_NOARGS, "SoShuttle_initClass()"},
	 { "new_SoShuttle", _wrap_new_SoShuttle, METH_NOARGS, "new_SoShuttle() -> SoShuttle"},
	 { "SoShuttle_translation0_set", _wrap_SoShuttle_translation0_set, METH_VARARGS, "SoShuttle_translation0_set(SoShuttle self, SoSFVec3f translation0)"},
	 { "SoShuttle_translation0_get", _wrap_SoShuttle_translation0_get, METH_O, "SoShuttle_translation0_get(SoShuttle self) -> SoSFVec3f"},
	 { "SoShuttle_translation1_set", _wrap_SoShuttle_translation1_set, METH_VARARGS, "SoShuttle_translation1_set(SoShuttle self, SoSFVec3f translation1)"},
	 { "SoShuttle_translation1_get", _wrap_SoShuttle_translation1_get, METH_O, "SoShuttle_translation1_get(SoShuttle self) -> SoSFVec3f"},
	 { "SoShuttle_speed_set", _wrap_SoShuttle_speed_set, METH_VARARGS, "SoShuttle_speed_set(SoShuttle self, SoSFFloat speed)"},
	 { "SoShuttle_speed_get", _wrap_SoShuttle_speed_get, METH_O, "SoShuttle_speed_get(SoShuttle self) -> SoSFFloat"},
	 { "SoShuttle_on_set", _wrap_SoShuttle_on_set, METH_VARARGS, "SoShuttle_on_set(SoShuttle self, SoSFBool on)"},
	 { "SoShuttle_on_get", _wrap_SoShuttle_on_get, METH_O, "SoShuttle_on_get(SoShuttle self) -> SoSFBool"},
	 { "SoShuttle_write", _wrap_SoShuttle_write, METH_VARARGS, "SoShuttle_write(SoShuttle self, SoWriteAction action)"},
	 { "SoShuttle_swigregister", SoShuttle_swigregister, METH_O, NULL},
	 { "SoShuttle_swiginit", SoShuttle_swiginit, METH_VARARGS, NULL},
	 { "SoSurroundScale_getClassTypeId", _wrap_SoSurroundScale_getClassTypeId, METH_NOARGS, "SoSurroundScale_getClassTypeId() -> SoType"},
	 { "SoSurroundScale_getTypeId", _wrap_SoSurroundScale_getTypeId, METH_O, "SoSurroundScale_getTypeId(SoSurroundScale self) -> SoType"},
	 { "SoSurroundScale_initClass", _wrap_SoSurroundScale_initClass, METH_NOARGS, "SoSurroundScale_initClass()"},
	 { "new_SoSurroundScale", _wrap_new_SoSurroundScale, METH_NOARGS, "new_SoSurroundScale() -> SoSurroundScale"},
	 { "SoSurroundScale_numNodesUpToContainer_set", _wrap_SoSurroundScale_numNodesUpToContainer_set, METH_VARARGS, "SoSurroundScale_numNodesUpToContainer_set(SoSurroundScale self, SoSFInt32 numNodesUpToContainer)"},
	 { "SoSurroundScale_numNodesUpToContainer_get", _wrap_SoSurroundScale_numNodesUpToContainer_get, METH_O, "SoSurroundScale_numNodesUpToContainer_get(SoSurroundScale self) -> SoSFInt32"},
	 { "SoSurroundScale_numNodesUpToReset_set", _wrap_SoSurroundScale_numNodesUpToReset_set, METH_VARARGS, "SoSurroundScale_numNodesUpToReset_set(SoSurroundScale self, SoSFInt32 numNodesUpToReset)"},
	 { "SoSurroundScale_numNodesUpToReset_get", _wrap_SoSurroundScale_numNodesUpToReset_get, METH_O, "SoSurroundScale_numNodesUpToReset_get(SoSurroundScale self) -> SoSFInt32"},
	 { "SoSurroundScale_invalidate", _wrap_SoSurroundScale_invalidate, METH_O, "SoSurroundScale_invalidate(SoSurroundScale self)"},
	 { "SoSurroundScale_doAction", _wrap_SoSurroundScale_doAction, METH_VARARGS, "SoSurroundScale_doAction(SoSurroundScale self, SoAction action)"},
	 { "SoSurroundScale_setDoingTranslations", _wrap_SoSurroundScale_setDoingTranslations, METH_VARARGS, "SoSurroundScale_setDoingTranslations(SoSurroundScale self, SbBool const val)"},
	 { "SoSurroundScale_isDoingTranslations", _wrap_SoSurroundScale_isDoingTranslations, METH_O, "SoSurroundScale_isDoingTranslations(SoSurroundScale self) -> SbBool"},
	 { "SoSurroundScale_swigregister", SoSurroundScale_swigregister, METH_O, NULL},
	 { "SoSurroundScale_swiginit", SoSurroundScale_swiginit, METH_VARARGS, NULL},
	 { "SoNurbsProfile_getClassTypeId", _wrap_SoNurbsProfile_getClassTypeId, METH_NOARGS, "SoNurbsProfile_getClassTypeId() -> SoType"},
	 { "SoNurbsProfile_getTypeId", _wrap_SoNurbsProfile_getTypeId, METH_O, "SoNurbsProfile_getTypeId(SoNurbsProfile self) -> SoType"},
	 { "SoNurbsProfile_initClass", _wrap_SoNurbsProfile_initClass, METH_NOARGS, "SoNurbsProfile_initClass()"},
	 { "new_SoNurbsProfile", _wrap_new_SoNurbsProfile, METH_NOARGS, "new_SoNurbsProfile() -> SoNurbsProfile"},
	 { "SoNurbsProfile_knotVector_set", _wrap_SoNurbsProfile_knotVector_set, METH_VARARGS, "SoNurbsProfile_knotVector_set(SoNurbsProfile self, SoMFFloat knotVector)"},
	 { "SoNurbsProfile_knotVector_get", _wrap_SoNurbsProfile_knotVector_get, METH_O, "SoNurbsProfile_knotVector_get(SoNurbsProfile self) -> SoMFFloat"},
	 { "SoNurbsProfile_getTrimCurve", _wrap_SoNurbsProfile_getTrimCurve, METH_VARARGS, "SoNurbsProfile_getTrimCurve(SoNurbsProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"},
	 { "SoNurbsProfile_getVertices", _wrap_SoNurbsProfile_getVertices, METH_VARARGS, "SoNurbsProfile_getVertices(SoNurbsProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"},
	 { "SoNurbsProfile_swigregister", SoNurbsProfile_swigregister, METH_O, NULL},
	 { "SoNurbsProfile_swiginit", SoNurbsProfile_swiginit, METH_VARARGS, NULL},
	 { "new_SoVertexAttribute", _wrap_new_SoVertexAttribute, METH_NOARGS, "new_SoVertexAttribute() -> SoVertexAttribute"},
	 { "SoVertexAttribute_initClass", _wrap_SoVertexAttribute_initClass, METH_NOARGS, "SoVertexAttribute_initClass()"},
	 { "SoVertexAttribute_getClassTypeId", _wrap_SoVertexAttribute_getClassTypeId, METH_NOARGS, "SoVertexAttribute_getClassTypeId() -> SoType"},
	 { "SoVertexAttribute_getTypeId", _wrap_SoVertexAttribute_getTypeId, METH_O, "SoVertexAttribute_getTypeId(SoVertexAttribute self) -> SoType"},
	 { "SoVertexAttribute_name_set", _wrap_SoVertexAttribute_name_set, METH_VARARGS, "SoVertexAttribute_name_set(SoVertexAttribute self, SoSFName name)"},
	 { "SoVertexAttribute_name_get", _wrap_SoVertexAttribute_name_get, METH_O, "SoVertexAttribute_name_get(SoVertexAttribute self) -> SoSFName"},
	 { "SoVertexAttribute_typeName_set", _wrap_SoVertexAttribute_typeName_set, METH_VARARGS, "SoVertexAttribute_typeName_set(SoVertexAttribute self, SoSFName typeName)"},
	 { "SoVertexAttribute_typeName_get", _wrap_SoVertexAttribute_typeName_get, METH_O, "SoVertexAttribute_typeName_get(SoVertexAttribute self) -> SoSFName"},
	 { "SoVertexAttribute_getValuesField", _wrap_SoVertexAttribute_getValuesField, METH_O, "SoVertexAttribute_getValuesField(SoVertexAttribute self) -> SoMField"},
	 { "SoVertexAttribute_doAction", _wrap_SoVertexAttribute_doAction, METH_VARARGS, "SoVertexAttribute_doAction(SoVertexAttribute self, SoAction action)"},
	 { "SoVertexAttribute_GLRender", _wrap_SoVertexAttribute_GLRender, METH_VARARGS, "SoVertexAttribute_GLRender(SoVertexAttribute self, SoGLRenderAction action)"},
	 { "SoVertexAttribute_write", _wrap_SoVertexAttribute_write, METH_VARARGS, "SoVertexAttribute_write(SoVertexAttribute self, SoWriteAction action)"},
	 { "SoVertexAttribute_copyContents", _wrap_SoVertexAttribute_copyContents, METH_VARARGS, "SoVertexAttribute_copyContents(SoVertexAttribute self, SoFieldContainer srcFrom, SbBool copyconnections)"},
	 { "SoVertexAttribute_notify", _wrap_SoVertexAttribute_notify, METH_VARARGS, "SoVertexAttribute_notify(SoVertexAttribute self, SoNotList l)"},
	 { "SoVertexAttribute_swigregister", SoVertexAttribute_swigregister, METH_O, NULL},
	 { "SoVertexAttribute_swiginit", SoVertexAttribute_swiginit, METH_VARARGS, NULL},
	 { "SoVertexAttributeBinding_getClassTypeId", _wrap_SoVertexAttributeBinding_getClassTypeId, METH_NOARGS, "SoVertexAttributeBinding_getClassTypeId() -> SoType"},
	 { "SoVertexAttributeBinding_getTypeId", _wrap_SoVertexAttributeBinding_getTypeId, METH_O, "SoVertexAttributeBinding_getTypeId(SoVertexAttributeBinding self) -> SoType"},
	 { "SoVertexAttributeBinding_initClass", _wrap_SoVertexAttributeBinding_initClass, METH_NOARGS, "SoVertexAttributeBinding_initClass()"},
	 { "new_SoVertexAttributeBinding", _wrap_new_SoVertexAttributeBinding, METH_NOARGS, "new_SoVertexAttributeBinding() -> SoVertexAttributeBinding"},
	 { "SoVertexAttributeBinding_value_set", _wrap_SoVertexAttributeBinding_value_set, METH_VARARGS, "SoVertexAttributeBinding_value_set(SoVertexAttributeBinding self, SoSFEnum value)"},
	 { "SoVertexAttributeBinding_value_get", _wrap_SoVertexAttributeBinding_value_get, METH_O, "SoVertexAttributeBinding_value_get(SoVertexAttributeBinding self) -> SoSFEnum"},
	 { "SoVertexAttributeBinding_doAction", _wrap_SoVertexAttributeBinding_doAction, METH_VARARGS, "SoVertexAttributeBinding_doAction(SoVertexAttributeBinding self, SoAction action)"},
	 { "SoVertexAttributeBinding_GLRender", _wrap_SoVertexAttributeBinding_GLRender, METH_VARARGS, "SoVertexAttributeBinding_GLRender(SoVertexAttributeBinding self, SoGLRenderAction action)"},
	 { "SoVertexAttributeBinding_callback", _wrap_SoVertexAttributeBinding_callback, METH_VARARGS, "SoVertexAttributeBinding_callback(SoVertexAttributeBinding self, SoCallbackAction action)"},
	 { "SoVertexAttributeBinding_pick", _wrap_SoVertexAttributeBinding_pick, METH_VARARGS, "SoVertexAttributeBinding_pick(SoVertexAttributeBinding self, SoPickAction action)"},
	 { "SoVertexAttributeBinding_getPrimitiveCount", _wrap_SoVertexAttributeBinding_getPrimitiveCount, METH_VARARGS, "SoVertexAttributeBinding_getPrimitiveCount(SoVertexAttributeBinding self, SoGetPrimitiveCountAction action)"},
	 { "SoVertexAttributeBinding_swigregister", SoVertexAttributeBinding_swigregister, METH_O, NULL},
	 { "SoVertexAttributeBinding_swiginit", SoVertexAttributeBinding_swiginit, METH_VARARGS, NULL},
	 { "SoNormal_getClassTypeId", _wrap_SoNormal_getClassTypeId, METH_NOARGS, "SoNormal_getClassTypeId() -> SoType"},
	 { "SoNormal_getTypeId", _wrap_SoNormal_getTypeId, METH_O, "SoNormal_getTypeId(SoNormal self) -> SoType"},
	 { "SoNormal_initClass", _wrap_SoNormal_initClass, METH_NOARGS, "SoNormal_initClass()"},
	 { "new_SoNormal", _wrap_new_SoNormal, METH_NOARGS, "new_SoNormal() -> SoNormal"},
	 { "SoNormal_vector_set", _wrap_SoNormal_vector_set, METH_VARARGS, "SoNormal_vector_set(SoNormal self, SoMFVec3f vector)"},
	 { "SoNormal_vector_get", _wrap_SoNormal_vector_get, METH_O, "SoNormal_vector_get(SoNormal self) -> SoMFVec3f"},
	 { "SoNormal_doAction", _wrap_SoNormal_doAction, METH_VARARGS, "SoNormal_doAction(SoNormal self, SoAction action)"},
	 { "SoNormal_GLRender", _wrap_SoNormal_GLRender, METH_VARARGS, "SoNormal_GLRender(SoNormal self, SoGLRenderAction action)"},
	 { "SoNormal_callback", _wrap_SoNormal_callback, METH_VARARGS, "SoNormal_callback(SoNormal self, SoCallbackAction action)"},
	 { "SoNormal_pick", _wrap_SoNormal_pick, METH_VARARGS, "SoNormal_pick(SoNormal self, SoPickAction action)"},
	 { "SoNormal_getPrimitiveCount", _wrap_SoNormal_getPrimitiveCount, METH_VARARGS, "SoNormal_getPrimitiveCount(SoNormal self, SoGetPrimitiveCountAction action)"},
	 { "SoNormal_swigregister", SoNormal_swigregister, METH_O, NULL},
	 { "SoNormal_swiginit", SoNormal_swiginit, METH_VARARGS, NULL},
	 { "SoPackedColor_getClassTypeId", _wrap_SoPackedColor_getClassTypeId, METH_NOARGS, "SoPackedColor_getClassTypeId() -> SoType"},
	 { "SoPackedColor_getTypeId", _wrap_SoPackedColor_getTypeId, METH_O, "SoPackedColor_getTypeId(SoPackedColor self) -> SoType"},
	 { "SoPackedColor_initClass", _wrap_SoPackedColor_initClass, METH_NOARGS, "SoPackedColor_initClass()"},
	 { "new_SoPackedColor", _wrap_new_SoPackedColor, METH_NOARGS, "new_SoPackedColor() -> SoPackedColor"},
	 { "SoPackedColor_orderedRGBA_set", _wrap_SoPackedColor_orderedRGBA_set, METH_VARARGS, "SoPackedColor_orderedRGBA_set(SoPackedColor self, SoMFUInt32 orderedRGBA)"},
	 { "SoPackedColor_orderedRGBA_get", _wrap_SoPackedColor_orderedRGBA_get, METH_O, "SoPackedColor_orderedRGBA_get(SoPackedColor self) -> SoMFUInt32"},
	 { "SoPackedColor_doAction", _wrap_SoPackedColor_doAction, METH_VARARGS, "SoPackedColor_doAction(SoPackedColor self, SoAction action)"},
	 { "SoPackedColor_GLRender", _wrap_SoPackedColor_GLRender, METH_VARARGS, "SoPackedColor_GLRender(SoPackedColor self, SoGLRenderAction action)"},
	 { "SoPackedColor_callback", _wrap_SoPackedColor_callback, METH_VARARGS, "SoPackedColor_callback(SoPackedColor self, SoCallbackAction action)"},
	 { "SoPackedColor_isTransparent", _wrap_SoPackedColor_isTransparent, METH_O, "SoPackedColor_isTransparent(SoPackedColor self) -> SbBool"},
	 { "SoPackedColor_swigregister", SoPackedColor_swigregister, METH_O, NULL},
	 { "SoPackedColor_swiginit", SoPackedColor_swiginit, METH_VARARGS, NULL},
	 { "SoPolygonOffset_getClassTypeId", _wrap_SoPolygonOffset_getClassTypeId, METH_NOARGS, "SoPolygonOffset_getClassTypeId() -> SoType"},
	 { "SoPolygonOffset_getTypeId", _wrap_SoPolygonOffset_getTypeId, METH_O, "SoPolygonOffset_getTypeId(SoPolygonOffset self) -> SoType"},
	 { "SoPolygonOffset_initClass", _wrap_SoPolygonOffset_initClass, METH_NOARGS, "SoPolygonOffset_initClass()"},
	 { "new_SoPolygonOffset", _wrap_new_SoPolygonOffset, METH_NOARGS, "new_SoPolygonOffset() -> SoPolygonOffset"},
	 { "SoPolygonOffset_factor_set", _wrap_SoPolygonOffset_factor_set, METH_VARARGS, "SoPolygonOffset_factor_set(SoPolygonOffset self, SoSFFloat factor)"},
	 { "SoPolygonOffset_factor_get", _wrap_SoPolygonOffset_factor_get, METH_O, "SoPolygonOffset_factor_get(SoPolygonOffset self) -> SoSFFloat"},
	 { "SoPolygonOffset_units_set", _wrap_SoPolygonOffset_units_set, METH_VARARGS, "SoPolygonOffset_units_set(SoPolygonOffset self, SoSFFloat units)"},
	 { "SoPolygonOffset_units_get", _wrap_SoPolygonOffset_units_get, METH_O, "SoPolygonOffset_units_get(SoPolygonOffset self) -> SoSFFloat"},
	 { "SoPolygonOffset_styles_set", _wrap_SoPolygonOffset_styles_set, METH_VARARGS, "SoPolygonOffset_styles_set(SoPolygonOffset self, SoSFBitMask styles)"},
	 { "SoPolygonOffset_styles_get", _wrap_SoPolygonOffset_styles_get, METH_O, "SoPolygonOffset_styles_get(SoPolygonOffset self) -> SoSFBitMask"},
	 { "SoPolygonOffset_on_set", _wrap_SoPolygonOffset_on_set, METH_VARARGS, "SoPolygonOffset_on_set(SoPolygonOffset self, SoSFBool on)"},
	 { "SoPolygonOffset_on_get", _wrap_SoPolygonOffset_on_get, METH_O, "SoPolygonOffset_on_get(SoPolygonOffset self) -> SoSFBool"},
	 { "SoPolygonOffset_doAction", _wrap_SoPolygonOffset_doAction, METH_VARARGS, "SoPolygonOffset_doAction(SoPolygonOffset self, SoAction action)"},
	 { "SoPolygonOffset_callback", _wrap_SoPolygonOffset_callback, METH_VARARGS, "SoPolygonOffset_callback(SoPolygonOffset self, SoCallbackAction action)"},
	 { "SoPolygonOffset_GLRender", _wrap_SoPolygonOffset_GLRender, METH_VARARGS, "SoPolygonOffset_GLRender(SoPolygonOffset self, SoGLRenderAction action)"},
	 { "SoPolygonOffset_swigregister", SoPolygonOffset_swigregister, METH_O, NULL},
	 { "SoPolygonOffset_swiginit", SoPolygonOffset_swiginit, METH_VARARGS, NULL},
	 { "SoProfileCoordinate2_getClassTypeId", _wrap_SoProfileCoordinate2_getClassTypeId, METH_NOARGS, "SoProfileCoordinate2_getClassTypeId() -> SoType"},
	 { "SoProfileCoordinate2_getTypeId", _wrap_SoProfileCoordinate2_getTypeId, METH_O, "SoProfileCoordinate2_getTypeId(SoProfileCoordinate2 self) -> SoType"},
	 { "SoProfileCoordinate2_initClass", _wrap_SoProfileCoordinate2_initClass, METH_NOARGS, "SoProfileCoordinate2_initClass()"},
	 { "new_SoProfileCoordinate2", _wrap_new_SoProfileCoordinate2, METH_NOARGS, "new_SoProfileCoordinate2() -> SoProfileCoordinate2"},
	 { "SoProfileCoordinate2_point_set", _wrap_SoProfileCoordinate2_point_set, METH_VARARGS, "SoProfileCoordinate2_point_set(SoProfileCoordinate2 self, SoMFVec2f point)"},
	 { "SoProfileCoordinate2_point_get", _wrap_SoProfileCoordinate2_point_get, METH_O, "SoProfileCoordinate2_point_get(SoProfileCoordinate2 self) -> SoMFVec2f"},
	 { "SoProfileCoordinate2_doAction", _wrap_SoProfileCoordinate2_doAction, METH_VARARGS, "SoProfileCoordinate2_doAction(SoProfileCoordinate2 self, SoAction action)"},
	 { "SoProfileCoordinate2_GLRender", _wrap_SoProfileCoordinate2_GLRender, METH_VARARGS, "SoProfileCoordinate2_GLRender(SoProfileCoordinate2 self, SoGLRenderAction action)"},
	 { "SoProfileCoordinate2_callback", _wrap_SoProfileCoordinate2_callback, METH_VARARGS, "SoProfileCoordinate2_callback(SoProfileCoordinate2 self, SoCallbackAction action)"},
	 { "SoProfileCoordinate2_pick", _wrap_SoProfileCoordinate2_pick, METH_VARARGS, "SoProfileCoordinate2_pick(SoProfileCoordinate2 self, SoPickAction action)"},
	 { "SoProfileCoordinate2_getBoundingBox", _wrap_SoProfileCoordinate2_getBoundingBox, METH_VARARGS, "SoProfileCoordinate2_getBoundingBox(SoProfileCoordinate2 self, SoGetBoundingBoxAction action)"},
	 { "SoProfileCoordinate2_getPrimitiveCount", _wrap_SoProfileCoordinate2_getPrimitiveCount, METH_VARARGS, "SoProfileCoordinate2_getPrimitiveCount(SoProfileCoordinate2 self, SoGetPrimitiveCountAction action)"},
	 { "SoProfileCoordinate2_swigregister", SoProfileCoordinate2_swigregister, METH_O, NULL},
	 { "SoProfileCoordinate2_swiginit", SoProfileCoordinate2_swiginit, METH_VARARGS, NULL},
	 { "SoProfileCoordinate3_getClassTypeId", _wrap_SoProfileCoordinate3_getClassTypeId, METH_NOARGS, "SoProfileCoordinate3_getClassTypeId() -> SoType"},
	 { "SoProfileCoordinate3_getTypeId", _wrap_SoProfileCoordinate3_getTypeId, METH_O, "SoProfileCoordinate3_getTypeId(SoProfileCoordinate3 self) -> SoType"},
	 { "SoProfileCoordinate3_initClass", _wrap_SoProfileCoordinate3_initClass, METH_NOARGS, "SoProfileCoordinate3_initClass()"},
	 { "new_SoProfileCoordinate3", _wrap_new_SoProfileCoordinate3, METH_NOARGS, "new_SoProfileCoordinate3() -> SoProfileCoordinate3"},
	 { "SoProfileCoordinate3_point_set", _wrap_SoProfileCoordinate3_point_set, METH_VARARGS, "SoProfileCoordinate3_point_set(SoProfileCoordinate3 self, SoMFVec3f point)"},
	 { "SoProfileCoordinate3_point_get", _wrap_SoProfileCoordinate3_point_get, METH_O, "SoProfileCoordinate3_point_get(SoProfileCoordinate3 self) -> SoMFVec3f"},
	 { "SoProfileCoordinate3_doAction", _wrap_SoProfileCoordinate3_doAction, METH_VARARGS, "SoProfileCoordinate3_doAction(SoProfileCoordinate3 self, SoAction action)"},
	 { "SoProfileCoordinate3_GLRender", _wrap_SoProfileCoordinate3_GLRender, METH_VARARGS, "SoProfileCoordinate3_GLRender(SoProfileCoordinate3 self, SoGLRenderAction action)"},
	 { "SoProfileCoordinate3_callback", _wrap_SoProfileCoordinate3_callback, METH_VARARGS, "SoProfileCoordinate3_callback(SoProfileCoordinate3 self, SoCallbackAction action)"},
	 { "SoProfileCoordinate3_pick", _wrap_SoProfileCoordinate3_pick, METH_VARARGS, "SoProfileCoordinate3_pick(SoProfileCoordinate3 self, SoPickAction action)"},
	 { "SoProfileCoordinate3_getBoundingBox", _wrap_SoProfileCoordinate3_getBoundingBox, METH_VARARGS, "SoProfileCoordinate3_getBoundingBox(SoProfileCoordinate3 self, SoGetBoundingBoxAction action)"},
	 { "SoProfileCoordinate3_getPrimitiveCount", _wrap_SoProfileCoordinate3_getPrimitiveCount, METH_VARARGS, "SoProfileCoordinate3_getPrimitiveCount(SoProfileCoordinate3 self, SoGetPrimitiveCountAction action)"},
	 { "SoProfileCoordinate3_swigregister", SoProfileCoordinate3_swigregister, METH_O, NULL},
	 { "SoProfileCoordinate3_swiginit", SoProfileCoordinate3_swiginit, METH_VARARGS, NULL},
	 { "SoTexture3_getClassTypeId", _wrap_SoTexture3_getClassTypeId, METH_NOARGS, "SoTexture3_getClassTypeId() -> SoType"},
	 { "SoTexture3_getTypeId", _wrap_SoTexture3_getTypeId, METH_O, "SoTexture3_getTypeId(SoTexture3 self) -> SoType"},
	 { "SoTexture3_initClass", _wrap_SoTexture3_initClass, METH_NOARGS, "SoTexture3_initClass()"},
	 { "new_SoTexture3", _wrap_new_SoTexture3, METH_NOARGS, "new_SoTexture3() -> SoTexture3"},
	 { "SoTexture3_filenames_set", _wrap_SoTexture3_filenames_set, METH_VARARGS, "SoTexture3_filenames_set(SoTexture3 self, SoMFString filenames)"},
	 { "SoTexture3_filenames_get", _wrap_SoTexture3_filenames_get, METH_O, "SoTexture3_filenames_get(SoTexture3 self) -> SoMFString"},
	 { "SoTexture3_images_set", _wrap_SoTexture3_images_set, METH_VARARGS, "SoTexture3_images_set(SoTexture3 self, SoSFImage3 images)"},
	 { "SoTexture3_images_get", _wrap_SoTexture3_images_get, METH_O, "SoTexture3_images_get(SoTexture3 self) -> SoSFImage3"},
	 { "SoTexture3_wrapR_set", _wrap_SoTexture3_wrapR_set, METH_VARARGS, "SoTexture3_wrapR_set(SoTexture3 self, SoSFEnum wrapR)"},
	 { "SoTexture3_wrapR_get", _wrap_SoTexture3_wrapR_get, METH_O, "SoTexture3_wrapR_get(SoTexture3 self) -> SoSFEnum"},
	 { "SoTexture3_wrapS_set", _wrap_SoTexture3_wrapS_set, METH_VARARGS, "SoTexture3_wrapS_set(SoTexture3 self, SoSFEnum wrapS)"},
	 { "SoTexture3_wrapS_get", _wrap_SoTexture3_wrapS_get, METH_O, "SoTexture3_wrapS_get(SoTexture3 self) -> SoSFEnum"},
	 { "SoTexture3_wrapT_set", _wrap_SoTexture3_wrapT_set, METH_VARARGS, "SoTexture3_wrapT_set(SoTexture3 self, SoSFEnum wrapT)"},
	 { "SoTexture3_wrapT_get", _wrap_SoTexture3_wrapT_get, METH_O, "SoTexture3_wrapT_get(SoTexture3 self) -> SoSFEnum"},
	 { "SoTexture3_model_set", _wrap_SoTexture3_model_set, METH_VARARGS, "SoTexture3_model_set(SoTexture3 self, SoSFEnum model)"},
	 { "SoTexture3_model_get", _wrap_SoTexture3_model_get, METH_O, "SoTexture3_model_get(SoTexture3 self) -> SoSFEnum"},
	 { "SoTexture3_blendColor_set", _wrap_SoTexture3_blendColor_set, METH_VARARGS, "SoTexture3_blendColor_set(SoTexture3 self, SoSFColor blendColor)"},
	 { "SoTexture3_blendColor_get", _wrap_SoTexture3_blendColor_get, METH_O, "SoTexture3_blendColor_get(SoTexture3 self) -> SoSFColor"},
	 { "SoTexture3_enableCompressedTexture_set", _wrap_SoTexture3_enableCompressedTexture_set, METH_VARARGS, "SoTexture3_enableCompressedTexture_set(SoTexture3 self, SoSFBool enableCompressedTexture)"},
	 { "SoTexture3_enableCompressedTexture_get", _wrap_SoTexture3_enableCompressedTexture_get, METH_O, "SoTexture3_enableCompressedTexture_get(SoTexture3 self) -> SoSFBool"},
	 { "SoTexture3_doAction", _wrap_SoTexture3_doAction, METH_VARARGS, "SoTexture3_doAction(SoTexture3 self, SoAction action)"},
	 { "SoTexture3_GLRender", _wrap_SoTexture3_GLRender, METH_VARARGS, "SoTexture3_GLRender(SoTexture3 self, SoGLRenderAction action)"},
	 { "SoTexture3_callback", _wrap_SoTexture3_callback, METH_VARARGS, "SoTexture3_callback(SoTexture3 self, SoCallbackAction action)"},
	 { "SoTexture3_swigregister", SoTexture3_swigregister, METH_O, NULL},
	 { "SoTexture3_swiginit", SoTexture3_swiginit, METH_VARARGS, NULL},
	 { "SoTexture2Transform_getClassTypeId", _wrap_SoTexture2Transform_getClassTypeId, METH_NOARGS, "SoTexture2Transform_getClassTypeId() -> SoType"},
	 { "SoTexture2Transform_getTypeId", _wrap_SoTexture2Transform_getTypeId, METH_O, "SoTexture2Transform_getTypeId(SoTexture2Transform self) -> SoType"},
	 { "SoTexture2Transform_initClass", _wrap_SoTexture2Transform_initClass, METH_NOARGS, "SoTexture2Transform_initClass()"},
	 { "new_SoTexture2Transform", _wrap_new_SoTexture2Transform, METH_NOARGS, "new_SoTexture2Transform() -> SoTexture2Transform"},
	 { "SoTexture2Transform_translation_set", _wrap_SoTexture2Transform_translation_set, METH_VARARGS, "SoTexture2Transform_translation_set(SoTexture2Transform self, SoSFVec2f translation)"},
	 { "SoTexture2Transform_translation_get", _wrap_SoTexture2Transform_translation_get, METH_O, "SoTexture2Transform_translation_get(SoTexture2Transform self) -> SoSFVec2f"},
	 { "SoTexture2Transform_rotation_set", _wrap_SoTexture2Transform_rotation_set, METH_VARARGS, "SoTexture2Transform_rotation_set(SoTexture2Transform self, SoSFFloat rotation)"},
	 { "SoTexture2Transform_rotation_get", _wrap_SoTexture2Transform_rotation_get, METH_O, "SoTexture2Transform_rotation_get(SoTexture2Transform self) -> SoSFFloat"},
	 { "SoTexture2Transform_scaleFactor_set", _wrap_SoTexture2Transform_scaleFactor_set, METH_VARARGS, "SoTexture2Transform_scaleFactor_set(SoTexture2Transform self, SoSFVec2f scaleFactor)"},
	 { "SoTexture2Transform_scaleFactor_get", _wrap_SoTexture2Transform_scaleFactor_get, METH_O, "SoTexture2Transform_scaleFactor_get(SoTexture2Transform self) -> SoSFVec2f"},
	 { "SoTexture2Transform_center_set", _wrap_SoTexture2Transform_center_set, METH_VARARGS, "SoTexture2Transform_center_set(SoTexture2Transform self, SoSFVec2f center)"},
	 { "SoTexture2Transform_center_get", _wrap_SoTexture2Transform_center_get, METH_O, "SoTexture2Transform_center_get(SoTexture2Transform self) -> SoSFVec2f"},
	 { "SoTexture2Transform_doAction", _wrap_SoTexture2Transform_doAction, METH_VARARGS, "SoTexture2Transform_doAction(SoTexture2Transform self, SoAction action)"},
	 { "SoTexture2Transform_callback", _wrap_SoTexture2Transform_callback, METH_VARARGS, "SoTexture2Transform_callback(SoTexture2Transform self, SoCallbackAction action)"},
	 { "SoTexture2Transform_GLRender", _wrap_SoTexture2Transform_GLRender, METH_VARARGS, "SoTexture2Transform_GLRender(SoTexture2Transform self, SoGLRenderAction action)"},
	 { "SoTexture2Transform_getMatrix", _wrap_SoTexture2Transform_getMatrix, METH_VARARGS, "SoTexture2Transform_getMatrix(SoTexture2Transform self, SoGetMatrixAction action)"},
	 { "SoTexture2Transform_pick", _wrap_SoTexture2Transform_pick, METH_VARARGS, "SoTexture2Transform_pick(SoTexture2Transform self, SoPickAction action)"},
	 { "SoTexture2Transform_swigregister", SoTexture2Transform_swigregister, METH_O, NULL},
	 { "SoTexture2Transform_swiginit", SoTexture2Transform_swiginit, METH_VARARGS, NULL},
	 { "SoTexture3Transform_getClassTypeId", _wrap_SoTexture3Transform_getClassTypeId, METH_NOARGS, "SoTexture3Transform_getClassTypeId() -> SoType"},
	 { "SoTexture3Transform_getTypeId", _wrap_SoTexture3Transform_getTypeId, METH_O, "SoTexture3Transform_getTypeId(SoTexture3Transform self) -> SoType"},
	 { "SoTexture3Transform_initClass", _wrap_SoTexture3Transform_initClass, METH_NOARGS, "SoTexture3Transform_initClass()"},
	 { "new_SoTexture3Transform", _wrap_new_SoTexture3Transform, METH_NOARGS, "new_SoTexture3Transform() -> SoTexture3Transform"},
	 { "SoTexture3Transform_translation_set", _wrap_SoTexture3Transform_translation_set, METH_VARARGS, "SoTexture3Transform_translation_set(SoTexture3Transform self, SoSFVec3f translation)"},
	 { "SoTexture3Transform_translation_get", _wrap_SoTexture3Transform_translation_get, METH_O, "SoTexture3Transform_translation_get(SoTexture3Transform self) -> SoSFVec3f"},
	 { "SoTexture3Transform_rotation_set", _wrap_SoTexture3Transform_rotation_set, METH_VARARGS, "SoTexture3Transform_rotation_set(SoTexture3Transform self, SoSFRotation rotation)"},
	 { "SoTexture3Transform_rotation_get", _wrap_SoTexture3Transform_rotation_get, METH_O, "SoTexture3Transform_rotation_get(SoTexture3Transform self) -> SoSFRotation"},
	 { "SoTexture3Transform_scaleFactor_set", _wrap_SoTexture3Transform_scaleFactor_set, METH_VARARGS, "SoTexture3Transform_scaleFactor_set(SoTexture3Transform self, SoSFVec3f scaleFactor)"},
	 { "SoTexture3Transform_scaleFactor_get", _wrap_SoTexture3Transform_scaleFactor_get, METH_O, "SoTexture3Transform_scaleFactor_get(SoTexture3Transform self) -> SoSFVec3f"},
	 { "SoTexture3Transform_scaleOrientation_set", _wrap_SoTexture3Transform_scaleOrientation_set, METH_VARARGS, "SoTexture3Transform_scaleOrientation_set(SoTexture3Transform self, SoSFRotation scaleOrientation)"},
	 { "SoTexture3Transform_scaleOrientation_get", _wrap_SoTexture3Transform_scaleOrientation_get, METH_O, "SoTexture3Transform_scaleOrientation_get(SoTexture3Transform self) -> SoSFRotation"},
	 { "SoTexture3Transform_center_set", _wrap_SoTexture3Transform_center_set, METH_VARARGS, "SoTexture3Transform_center_set(SoTexture3Transform self, SoSFVec3f center)"},
	 { "SoTexture3Transform_center_get", _wrap_SoTexture3Transform_center_get, METH_O, "SoTexture3Transform_center_get(SoTexture3Transform self) -> SoSFVec3f"},
	 { "SoTexture3Transform_doAction", _wrap_SoTexture3Transform_doAction, METH_VARARGS, "SoTexture3Transform_doAction(SoTexture3Transform self, SoAction action)"},
	 { "SoTexture3Transform_callback", _wrap_SoTexture3Transform_callback, METH_VARARGS, "SoTexture3Transform_callback(SoTexture3Transform self, SoCallbackAction action)"},
	 { "SoTexture3Transform_GLRender", _wrap_SoTexture3Transform_GLRender, METH_VARARGS, "SoTexture3Transform_GLRender(SoTexture3Transform self, SoGLRenderAction action)"},
	 { "SoTexture3Transform_getMatrix", _wrap_SoTexture3Transform_getMatrix, METH_VARARGS, "SoTexture3Transform_getMatrix(SoTexture3Transform self, SoGetMatrixAction action)"},
	 { "SoTexture3Transform_pick", _wrap_SoTexture3Transform_pick, METH_VARARGS, "SoTexture3Transform_pick(SoTexture3Transform self, SoPickAction action)"},
	 { "SoTexture3Transform_swigregister", SoTexture3Transform_swigregister, METH_O, NULL},
	 { "SoTexture3Transform_swiginit", SoTexture3Transform_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinate2_getClassTypeId", _wrap_SoTextureCoordinate2_getClassTypeId, METH_NOARGS, "SoTextureCoordinate2_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinate2_getTypeId", _wrap_SoTextureCoordinate2_getTypeId, METH_O, "SoTextureCoordinate2_getTypeId(SoTextureCoordinate2 self) -> SoType"},
	 { "SoTextureCoordinate2_initClass", _wrap_SoTextureCoordinate2_initClass, METH_NOARGS, "SoTextureCoordinate2_initClass()"},
	 { "new_SoTextureCoordinate2", _wrap_new_SoTextureCoordinate2, METH_NOARGS, "new_SoTextureCoordinate2() -> SoTextureCoordinate2"},
	 { "SoTextureCoordinate2_point_set", _wrap_SoTextureCoordinate2_point_set, METH_VARARGS, "SoTextureCoordinate2_point_set(SoTextureCoordinate2 self, SoMFVec2f point)"},
	 { "SoTextureCoordinate2_point_get", _wrap_SoTextureCoordinate2_point_get, METH_O, "SoTextureCoordinate2_point_get(SoTextureCoordinate2 self) -> SoMFVec2f"},
	 { "SoTextureCoordinate2_doAction", _wrap_SoTextureCoordinate2_doAction, METH_VARARGS, "SoTextureCoordinate2_doAction(SoTextureCoordinate2 self, SoAction action)"},
	 { "SoTextureCoordinate2_GLRender", _wrap_SoTextureCoordinate2_GLRender, METH_VARARGS, "SoTextureCoordinate2_GLRender(SoTextureCoordinate2 self, SoGLRenderAction action)"},
	 { "SoTextureCoordinate2_callback", _wrap_SoTextureCoordinate2_callback, METH_VARARGS, "SoTextureCoordinate2_callback(SoTextureCoordinate2 self, SoCallbackAction action)"},
	 { "SoTextureCoordinate2_pick", _wrap_SoTextureCoordinate2_pick, METH_VARARGS, "SoTextureCoordinate2_pick(SoTextureCoordinate2 self, SoPickAction action)"},
	 { "SoTextureCoordinate2_swigregister", SoTextureCoordinate2_swigregister, METH_O, NULL},
	 { "SoTextureCoordinate2_swiginit", SoTextureCoordinate2_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinate3_getClassTypeId", _wrap_SoTextureCoordinate3_getClassTypeId, METH_NOARGS, "SoTextureCoordinate3_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinate3_getTypeId", _wrap_SoTextureCoordinate3_getTypeId, METH_O, "SoTextureCoordinate3_getTypeId(SoTextureCoordinate3 self) -> SoType"},
	 { "SoTextureCoordinate3_initClass", _wrap_SoTextureCoordinate3_initClass, METH_NOARGS, "SoTextureCoordinate3_initClass()"},
	 { "new_SoTextureCoordinate3", _wrap_new_SoTextureCoordinate3, METH_NOARGS, "new_SoTextureCoordinate3() -> SoTextureCoordinate3"},
	 { "SoTextureCoordinate3_point_set", _wrap_SoTextureCoordinate3_point_set, METH_VARARGS, "SoTextureCoordinate3_point_set(SoTextureCoordinate3 self, SoMFVec3f point)"},
	 { "SoTextureCoordinate3_point_get", _wrap_SoTextureCoordinate3_point_get, METH_O, "SoTextureCoordinate3_point_get(SoTextureCoordinate3 self) -> SoMFVec3f"},
	 { "SoTextureCoordinate3_doAction", _wrap_SoTextureCoordinate3_doAction, METH_VARARGS, "SoTextureCoordinate3_doAction(SoTextureCoordinate3 self, SoAction action)"},
	 { "SoTextureCoordinate3_GLRender", _wrap_SoTextureCoordinate3_GLRender, METH_VARARGS, "SoTextureCoordinate3_GLRender(SoTextureCoordinate3 self, SoGLRenderAction action)"},
	 { "SoTextureCoordinate3_callback", _wrap_SoTextureCoordinate3_callback, METH_VARARGS, "SoTextureCoordinate3_callback(SoTextureCoordinate3 self, SoCallbackAction action)"},
	 { "SoTextureCoordinate3_pick", _wrap_SoTextureCoordinate3_pick, METH_VARARGS, "SoTextureCoordinate3_pick(SoTextureCoordinate3 self, SoPickAction action)"},
	 { "SoTextureCoordinate3_swigregister", SoTextureCoordinate3_swigregister, METH_O, NULL},
	 { "SoTextureCoordinate3_swiginit", SoTextureCoordinate3_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateFunction_getClassTypeId", _wrap_SoTextureCoordinateFunction_getClassTypeId, METH_NOARGS, "SoTextureCoordinateFunction_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateFunction_getTypeId", _wrap_SoTextureCoordinateFunction_getTypeId, METH_O, "SoTextureCoordinateFunction_getTypeId(SoTextureCoordinateFunction self) -> SoType"},
	 { "SoTextureCoordinateFunction_initClass", _wrap_SoTextureCoordinateFunction_initClass, METH_NOARGS, "SoTextureCoordinateFunction_initClass()"},
	 { "new_SoTextureCoordinateFunction", _wrap_new_SoTextureCoordinateFunction, METH_NOARGS, "new_SoTextureCoordinateFunction() -> SoTextureCoordinateFunction"},
	 { "SoTextureCoordinateFunction_swigregister", SoTextureCoordinateFunction_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateFunction_swiginit", SoTextureCoordinateFunction_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateDefault_getClassTypeId", _wrap_SoTextureCoordinateDefault_getClassTypeId, METH_NOARGS, "SoTextureCoordinateDefault_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateDefault_getTypeId", _wrap_SoTextureCoordinateDefault_getTypeId, METH_O, "SoTextureCoordinateDefault_getTypeId(SoTextureCoordinateDefault self) -> SoType"},
	 { "SoTextureCoordinateDefault_initClass", _wrap_SoTextureCoordinateDefault_initClass, METH_NOARGS, "SoTextureCoordinateDefault_initClass()"},
	 { "new_SoTextureCoordinateDefault", _wrap_new_SoTextureCoordinateDefault, METH_NOARGS, "new_SoTextureCoordinateDefault() -> SoTextureCoordinateDefault"},
	 { "SoTextureCoordinateDefault_doAction", _wrap_SoTextureCoordinateDefault_doAction, METH_VARARGS, "SoTextureCoordinateDefault_doAction(SoTextureCoordinateDefault self, SoAction action)"},
	 { "SoTextureCoordinateDefault_GLRender", _wrap_SoTextureCoordinateDefault_GLRender, METH_VARARGS, "SoTextureCoordinateDefault_GLRender(SoTextureCoordinateDefault self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateDefault_callback", _wrap_SoTextureCoordinateDefault_callback, METH_VARARGS, "SoTextureCoordinateDefault_callback(SoTextureCoordinateDefault self, SoCallbackAction action)"},
	 { "SoTextureCoordinateDefault_pick", _wrap_SoTextureCoordinateDefault_pick, METH_VARARGS, "SoTextureCoordinateDefault_pick(SoTextureCoordinateDefault self, SoPickAction action)"},
	 { "SoTextureCoordinateDefault_swigregister", SoTextureCoordinateDefault_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateDefault_swiginit", SoTextureCoordinateDefault_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateEnvironment_getClassTypeId", _wrap_SoTextureCoordinateEnvironment_getClassTypeId, METH_NOARGS, "SoTextureCoordinateEnvironment_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateEnvironment_getTypeId", _wrap_SoTextureCoordinateEnvironment_getTypeId, METH_O, "SoTextureCoordinateEnvironment_getTypeId(SoTextureCoordinateEnvironment self) -> SoType"},
	 { "SoTextureCoordinateEnvironment_initClass", _wrap_SoTextureCoordinateEnvironment_initClass, METH_NOARGS, "SoTextureCoordinateEnvironment_initClass()"},
	 { "new_SoTextureCoordinateEnvironment", _wrap_new_SoTextureCoordinateEnvironment, METH_NOARGS, "new_SoTextureCoordinateEnvironment() -> SoTextureCoordinateEnvironment"},
	 { "SoTextureCoordinateEnvironment_doAction", _wrap_SoTextureCoordinateEnvironment_doAction, METH_VARARGS, "SoTextureCoordinateEnvironment_doAction(SoTextureCoordinateEnvironment self, SoAction action)"},
	 { "SoTextureCoordinateEnvironment_GLRender", _wrap_SoTextureCoordinateEnvironment_GLRender, METH_VARARGS, "SoTextureCoordinateEnvironment_GLRender(SoTextureCoordinateEnvironment self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateEnvironment_pick", _wrap_SoTextureCoordinateEnvironment_pick, METH_VARARGS, "SoTextureCoordinateEnvironment_pick(SoTextureCoordinateEnvironment self, SoPickAction action)"},
	 { "SoTextureCoordinateEnvironment_callback", _wrap_SoTextureCoordinateEnvironment_callback, METH_VARARGS, "SoTextureCoordinateEnvironment_callback(SoTextureCoordinateEnvironment self, SoCallbackAction action)"},
	 { "SoTextureCoordinateEnvironment_swigregister", SoTextureCoordinateEnvironment_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateEnvironment_swiginit", SoTextureCoordinateEnvironment_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinatePlane_getClassTypeId", _wrap_SoTextureCoordinatePlane_getClassTypeId, METH_NOARGS, "SoTextureCoordinatePlane_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinatePlane_getTypeId", _wrap_SoTextureCoordinatePlane_getTypeId, METH_O, "SoTextureCoordinatePlane_getTypeId(SoTextureCoordinatePlane self) -> SoType"},
	 { "SoTextureCoordinatePlane_initClass", _wrap_SoTextureCoordinatePlane_initClass, METH_NOARGS, "SoTextureCoordinatePlane_initClass()"},
	 { "new_SoTextureCoordinatePlane", _wrap_new_SoTextureCoordinatePlane, METH_NOARGS, "new_SoTextureCoordinatePlane() -> SoTextureCoordinatePlane"},
	 { "SoTextureCoordinatePlane_directionS_set", _wrap_SoTextureCoordinatePlane_directionS_set, METH_VARARGS, "SoTextureCoordinatePlane_directionS_set(SoTextureCoordinatePlane self, SoSFVec3f directionS)"},
	 { "SoTextureCoordinatePlane_directionS_get", _wrap_SoTextureCoordinatePlane_directionS_get, METH_O, "SoTextureCoordinatePlane_directionS_get(SoTextureCoordinatePlane self) -> SoSFVec3f"},
	 { "SoTextureCoordinatePlane_directionT_set", _wrap_SoTextureCoordinatePlane_directionT_set, METH_VARARGS, "SoTextureCoordinatePlane_directionT_set(SoTextureCoordinatePlane self, SoSFVec3f directionT)"},
	 { "SoTextureCoordinatePlane_directionT_get", _wrap_SoTextureCoordinatePlane_directionT_get, METH_O, "SoTextureCoordinatePlane_directionT_get(SoTextureCoordinatePlane self) -> SoSFVec3f"},
	 { "SoTextureCoordinatePlane_directionR_set", _wrap_SoTextureCoordinatePlane_directionR_set, METH_VARARGS, "SoTextureCoordinatePlane_directionR_set(SoTextureCoordinatePlane self, SoSFVec3f directionR)"},
	 { "SoTextureCoordinatePlane_directionR_get", _wrap_SoTextureCoordinatePlane_directionR_get, METH_O, "SoTextureCoordinatePlane_directionR_get(SoTextureCoordinatePlane self) -> SoSFVec3f"},
	 { "SoTextureCoordinatePlane_doAction", _wrap_SoTextureCoordinatePlane_doAction, METH_VARARGS, "SoTextureCoordinatePlane_doAction(SoTextureCoordinatePlane self, SoAction action)"},
	 { "SoTextureCoordinatePlane_GLRender", _wrap_SoTextureCoordinatePlane_GLRender, METH_VARARGS, "SoTextureCoordinatePlane_GLRender(SoTextureCoordinatePlane self, SoGLRenderAction action)"},
	 { "SoTextureCoordinatePlane_pick", _wrap_SoTextureCoordinatePlane_pick, METH_VARARGS, "SoTextureCoordinatePlane_pick(SoTextureCoordinatePlane self, SoPickAction action)"},
	 { "SoTextureCoordinatePlane_callback", _wrap_SoTextureCoordinatePlane_callback, METH_VARARGS, "SoTextureCoordinatePlane_callback(SoTextureCoordinatePlane self, SoCallbackAction action)"},
	 { "SoTextureCoordinatePlane_swigregister", SoTextureCoordinatePlane_swigregister, METH_O, NULL},
	 { "SoTextureCoordinatePlane_swiginit", SoTextureCoordinatePlane_swiginit, METH_VARARGS, NULL},
	 { "SoTextureMatrixTransform_getClassTypeId", _wrap_SoTextureMatrixTransform_getClassTypeId, METH_NOARGS, "SoTextureMatrixTransform_getClassTypeId() -> SoType"},
	 { "SoTextureMatrixTransform_getTypeId", _wrap_SoTextureMatrixTransform_getTypeId, METH_O, "SoTextureMatrixTransform_getTypeId(SoTextureMatrixTransform self) -> SoType"},
	 { "SoTextureMatrixTransform_initClass", _wrap_SoTextureMatrixTransform_initClass, METH_NOARGS, "SoTextureMatrixTransform_initClass()"},
	 { "new_SoTextureMatrixTransform", _wrap_new_SoTextureMatrixTransform, METH_NOARGS, "new_SoTextureMatrixTransform() -> SoTextureMatrixTransform"},
	 { "SoTextureMatrixTransform_matrix_set", _wrap_SoTextureMatrixTransform_matrix_set, METH_VARARGS, "SoTextureMatrixTransform_matrix_set(SoTextureMatrixTransform self, SoSFMatrix matrix)"},
	 { "SoTextureMatrixTransform_matrix_get", _wrap_SoTextureMatrixTransform_matrix_get, METH_O, "SoTextureMatrixTransform_matrix_get(SoTextureMatrixTransform self) -> SoSFMatrix"},
	 { "SoTextureMatrixTransform_doAction", _wrap_SoTextureMatrixTransform_doAction, METH_VARARGS, "SoTextureMatrixTransform_doAction(SoTextureMatrixTransform self, SoAction action)"},
	 { "SoTextureMatrixTransform_callback", _wrap_SoTextureMatrixTransform_callback, METH_VARARGS, "SoTextureMatrixTransform_callback(SoTextureMatrixTransform self, SoCallbackAction action)"},
	 { "SoTextureMatrixTransform_GLRender", _wrap_SoTextureMatrixTransform_GLRender, METH_VARARGS, "SoTextureMatrixTransform_GLRender(SoTextureMatrixTransform self, SoGLRenderAction action)"},
	 { "SoTextureMatrixTransform_getMatrix", _wrap_SoTextureMatrixTransform_getMatrix, METH_VARARGS, "SoTextureMatrixTransform_getMatrix(SoTextureMatrixTransform self, SoGetMatrixAction action)"},
	 { "SoTextureMatrixTransform_pick", _wrap_SoTextureMatrixTransform_pick, METH_VARARGS, "SoTextureMatrixTransform_pick(SoTextureMatrixTransform self, SoPickAction action)"},
	 { "SoTextureMatrixTransform_swigregister", SoTextureMatrixTransform_swigregister, METH_O, NULL},
	 { "SoTextureMatrixTransform_swiginit", SoTextureMatrixTransform_swiginit, METH_VARARGS, NULL},
	 { "SoWWWInline_getClassTypeId", _wrap_SoWWWInline_getClassTypeId, METH_NOARGS, "SoWWWInline_getClassTypeId() -> SoType"},
	 { "SoWWWInline_getTypeId", _wrap_SoWWWInline_getTypeId, METH_O, "SoWWWInline_getTypeId(SoWWWInline self) -> SoType"},
	 { "SoWWWInline_initClass", _wrap_SoWWWInline_initClass, METH_NOARGS, "SoWWWInline_initClass()"},
	 { "new_SoWWWInline", _wrap_new_SoWWWInline, METH_NOARGS, "new_SoWWWInline() -> SoWWWInline"},
	 { "SoWWWInline_name_set", _wrap_SoWWWInline_name_set, METH_VARARGS, "SoWWWInline_name_set(SoWWWInline self, SoSFString name)"},
	 { "SoWWWInline_name_get", _wrap_SoWWWInline_name_get, METH_O, "SoWWWInline_name_get(SoWWWInline self) -> SoSFString"},
	 { "SoWWWInline_bboxCenter_set", _wrap_SoWWWInline_bboxCenter_set, METH_VARARGS, "SoWWWInline_bboxCenter_set(SoWWWInline self, SoSFVec3f bboxCenter)"},
	 { "SoWWWInline_bboxCenter_get", _wrap_SoWWWInline_bboxCenter_get, METH_O, "SoWWWInline_bboxCenter_get(SoWWWInline self) -> SoSFVec3f"},
	 { "SoWWWInline_bboxSize_set", _wrap_SoWWWInline_bboxSize_set, METH_VARARGS, "SoWWWInline_bboxSize_set(SoWWWInline self, SoSFVec3f bboxSize)"},
	 { "SoWWWInline_bboxSize_get", _wrap_SoWWWInline_bboxSize_get, METH_O, "SoWWWInline_bboxSize_get(SoWWWInline self) -> SoSFVec3f"},
	 { "SoWWWInline_alternateRep_set", _wrap_SoWWWInline_alternateRep_set, METH_VARARGS, "SoWWWInline_alternateRep_set(SoWWWInline self, SoSFNode alternateRep)"},
	 { "SoWWWInline_alternateRep_get", _wrap_SoWWWInline_alternateRep_get, METH_O, "SoWWWInline_alternateRep_get(SoWWWInline self) -> SoSFNode"},
	 { "SoWWWInline_setFullURLName", _wrap_SoWWWInline_setFullURLName, METH_VARARGS, "SoWWWInline_setFullURLName(SoWWWInline self, SbString url)"},
	 { "SoWWWInline_getFullURLName", _wrap_SoWWWInline_getFullURLName, METH_O, "SoWWWInline_getFullURLName(SoWWWInline self) -> SbString"},
	 { "SoWWWInline_copyChildren", _wrap_SoWWWInline_copyChildren, METH_O, "SoWWWInline_copyChildren(SoWWWInline self) -> SoGroup"},
	 { "SoWWWInline_requestURLData", _wrap_SoWWWInline_requestURLData, METH_O, "SoWWWInline_requestURLData(SoWWWInline self)"},
	 { "SoWWWInline_isURLDataRequested", _wrap_SoWWWInline_isURLDataRequested, METH_O, "SoWWWInline_isURLDataRequested(SoWWWInline self) -> SbBool"},
	 { "SoWWWInline_isURLDataHere", _wrap_SoWWWInline_isURLDataHere, METH_O, "SoWWWInline_isURLDataHere(SoWWWInline self) -> SbBool"},
	 { "SoWWWInline_cancelURLDataRequest", _wrap_SoWWWInline_cancelURLDataRequest, METH_O, "SoWWWInline_cancelURLDataRequest(SoWWWInline self)"},
	 { "SoWWWInline_setChildData", _wrap_SoWWWInline_setChildData, METH_VARARGS, "SoWWWInline_setChildData(SoWWWInline self, SoNode urldata)"},
	 { "SoWWWInline_getChildData", _wrap_SoWWWInline_getChildData, METH_O, "SoWWWInline_getChildData(SoWWWInline self) -> SoNode"},
	 { "SoWWWInline_getChildren", _wrap_SoWWWInline_getChildren, METH_O, "SoWWWInline_getChildren(SoWWWInline self) -> SoChildList"},
	 { "SoWWWInline_setFetchURLCallBack", _wrap_SoWWWInline_setFetchURLCallBack, METH_VARARGS, "SoWWWInline_setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"},
	 { "SoWWWInline_setBoundingBoxVisibility", _wrap_SoWWWInline_setBoundingBoxVisibility, METH_O, "SoWWWInline_setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"},
	 { "SoWWWInline_getBoundingBoxVisibility", _wrap_SoWWWInline_getBoundingBoxVisibility, METH_NOARGS, "SoWWWInline_getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"},
	 { "SoWWWInline_setBoundingBoxColor", _wrap_SoWWWInline_setBoundingBoxColor, METH_O, "SoWWWInline_setBoundingBoxColor(SbColor c)"},
	 { "SoWWWInline_getBoundingBoxColor", _wrap_SoWWWInline_getBoundingBoxColor, METH_NOARGS, "SoWWWInline_getBoundingBoxColor() -> SbColor"},
	 { "SoWWWInline_setReadAsSoFile", _wrap_SoWWWInline_setReadAsSoFile, METH_O, "SoWWWInline_setReadAsSoFile(SbBool onoff)"},
	 { "SoWWWInline_getReadAsSoFile", _wrap_SoWWWInline_getReadAsSoFile, METH_NOARGS, "SoWWWInline_getReadAsSoFile() -> SbBool"},
	 { "SoWWWInline_doAction", _wrap_SoWWWInline_doAction, METH_VARARGS, "SoWWWInline_doAction(SoWWWInline self, SoAction action)"},
	 { "SoWWWInline_doActionOnKidsOrBox", _wrap_SoWWWInline_doActionOnKidsOrBox, METH_VARARGS, "SoWWWInline_doActionOnKidsOrBox(SoWWWInline self, SoAction action)"},
	 { "SoWWWInline_callback", _wrap_SoWWWInline_callback, METH_VARARGS, "SoWWWInline_callback(SoWWWInline self, SoCallbackAction action)"},
	 { "SoWWWInline_GLRender", _wrap_SoWWWInline_GLRender, METH_VARARGS, "SoWWWInline_GLRender(SoWWWInline self, SoGLRenderAction action)"},
	 { "SoWWWInline_getBoundingBox", _wrap_SoWWWInline_getBoundingBox, METH_VARARGS, "SoWWWInline_getBoundingBox(SoWWWInline self, SoGetBoundingBoxAction action)"},
	 { "SoWWWInline_getMatrix", _wrap_SoWWWInline_getMatrix, METH_VARARGS, "SoWWWInline_getMatrix(SoWWWInline self, SoGetMatrixAction action)"},
	 { "SoWWWInline_handleEvent", _wrap_SoWWWInline_handleEvent, METH_VARARGS, "SoWWWInline_handleEvent(SoWWWInline self, SoHandleEventAction action)"},
	 { "SoWWWInline_search", _wrap_SoWWWInline_search, METH_VARARGS, "SoWWWInline_search(SoWWWInline self, SoSearchAction action)"},
	 { "SoWWWInline_pick", _wrap_SoWWWInline_pick, METH_VARARGS, "SoWWWInline_pick(SoWWWInline self, SoPickAction action)"},
	 { "SoWWWInline_getPrimitiveCount", _wrap_SoWWWInline_getPrimitiveCount, METH_VARARGS, "SoWWWInline_getPrimitiveCount(SoWWWInline self, SoGetPrimitiveCountAction action)"},
	 { "SoWWWInline_audioRender", _wrap_SoWWWInline_audioRender, METH_VARARGS, "SoWWWInline_audioRender(SoWWWInline self, SoAudioRenderAction action)"},
	 { "SoWWWInline_swigregister", SoWWWInline_swigregister, METH_O, NULL},
	 { "SoWWWInline_swiginit", SoWWWInline_swiginit, METH_VARARGS, NULL},
	 { "SoTransparencyType_getClassTypeId", _wrap_SoTransparencyType_getClassTypeId, METH_NOARGS, "SoTransparencyType_getClassTypeId() -> SoType"},
	 { "SoTransparencyType_getTypeId", _wrap_SoTransparencyType_getTypeId, METH_O, "SoTransparencyType_getTypeId(SoTransparencyType self) -> SoType"},
	 { "SoTransparencyType_initClass", _wrap_SoTransparencyType_initClass, METH_NOARGS, "SoTransparencyType_initClass()"},
	 { "new_SoTransparencyType", _wrap_new_SoTransparencyType, METH_NOARGS, "new_SoTransparencyType() -> SoTransparencyType"},
	 { "SoTransparencyType_value_set", _wrap_SoTransparencyType_value_set, METH_VARARGS, "SoTransparencyType_value_set(SoTransparencyType self, SoSFEnum value)"},
	 { "SoTransparencyType_value_get", _wrap_SoTransparencyType_value_get, METH_O, "SoTransparencyType_value_get(SoTransparencyType self) -> SoSFEnum"},
	 { "SoTransparencyType_doAction", _wrap_SoTransparencyType_doAction, METH_VARARGS, "SoTransparencyType_doAction(SoTransparencyType self, SoAction action)"},
	 { "SoTransparencyType_GLRender", _wrap_SoTransparencyType_GLRender, METH_VARARGS, "SoTransparencyType_GLRender(SoTransparencyType self, SoGLRenderAction action)"},
	 { "SoTransparencyType_callback", _wrap_SoTransparencyType_callback, METH_VARARGS, "SoTransparencyType_callback(SoTransparencyType self, SoCallbackAction action)"},
	 { "SoTransparencyType_swigregister", SoTransparencyType_swigregister, METH_O, NULL},
	 { "SoTransparencyType_swiginit", SoTransparencyType_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateCube_getClassTypeId", _wrap_SoTextureCoordinateCube_getClassTypeId, METH_NOARGS, "SoTextureCoordinateCube_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateCube_getTypeId", _wrap_SoTextureCoordinateCube_getTypeId, METH_O, "SoTextureCoordinateCube_getTypeId(SoTextureCoordinateCube self) -> SoType"},
	 { "SoTextureCoordinateCube_initClass", _wrap_SoTextureCoordinateCube_initClass, METH_NOARGS, "SoTextureCoordinateCube_initClass()"},
	 { "new_SoTextureCoordinateCube", _wrap_new_SoTextureCoordinateCube, METH_NOARGS, "new_SoTextureCoordinateCube() -> SoTextureCoordinateCube"},
	 { "SoTextureCoordinateCube_doAction", _wrap_SoTextureCoordinateCube_doAction, METH_VARARGS, "SoTextureCoordinateCube_doAction(SoTextureCoordinateCube self, SoAction action)"},
	 { "SoTextureCoordinateCube_GLRender", _wrap_SoTextureCoordinateCube_GLRender, METH_VARARGS, "SoTextureCoordinateCube_GLRender(SoTextureCoordinateCube self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateCube_callback", _wrap_SoTextureCoordinateCube_callback, METH_VARARGS, "SoTextureCoordinateCube_callback(SoTextureCoordinateCube self, SoCallbackAction action)"},
	 { "SoTextureCoordinateCube_pick", _wrap_SoTextureCoordinateCube_pick, METH_VARARGS, "SoTextureCoordinateCube_pick(SoTextureCoordinateCube self, SoPickAction action)"},
	 { "SoTextureCoordinateCube_swigregister", SoTextureCoordinateCube_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateCube_swiginit", SoTextureCoordinateCube_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateSphere_getClassTypeId", _wrap_SoTextureCoordinateSphere_getClassTypeId, METH_NOARGS, "SoTextureCoordinateSphere_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateSphere_getTypeId", _wrap_SoTextureCoordinateSphere_getTypeId, METH_O, "SoTextureCoordinateSphere_getTypeId(SoTextureCoordinateSphere self) -> SoType"},
	 { "SoTextureCoordinateSphere_initClass", _wrap_SoTextureCoordinateSphere_initClass, METH_NOARGS, "SoTextureCoordinateSphere_initClass()"},
	 { "new_SoTextureCoordinateSphere", _wrap_new_SoTextureCoordinateSphere, METH_NOARGS, "new_SoTextureCoordinateSphere() -> SoTextureCoordinateSphere"},
	 { "SoTextureCoordinateSphere_doAction", _wrap_SoTextureCoordinateSphere_doAction, METH_VARARGS, "SoTextureCoordinateSphere_doAction(SoTextureCoordinateSphere self, SoAction action)"},
	 { "SoTextureCoordinateSphere_GLRender", _wrap_SoTextureCoordinateSphere_GLRender, METH_VARARGS, "SoTextureCoordinateSphere_GLRender(SoTextureCoordinateSphere self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateSphere_callback", _wrap_SoTextureCoordinateSphere_callback, METH_VARARGS, "SoTextureCoordinateSphere_callback(SoTextureCoordinateSphere self, SoCallbackAction action)"},
	 { "SoTextureCoordinateSphere_pick", _wrap_SoTextureCoordinateSphere_pick, METH_VARARGS, "SoTextureCoordinateSphere_pick(SoTextureCoordinateSphere self, SoPickAction action)"},
	 { "SoTextureCoordinateSphere_swigregister", SoTextureCoordinateSphere_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateSphere_swiginit", SoTextureCoordinateSphere_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateCylinder_getClassTypeId", _wrap_SoTextureCoordinateCylinder_getClassTypeId, METH_NOARGS, "SoTextureCoordinateCylinder_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateCylinder_getTypeId", _wrap_SoTextureCoordinateCylinder_getTypeId, METH_O, "SoTextureCoordinateCylinder_getTypeId(SoTextureCoordinateCylinder self) -> SoType"},
	 { "SoTextureCoordinateCylinder_initClass", _wrap_SoTextureCoordinateCylinder_initClass, METH_NOARGS, "SoTextureCoordinateCylinder_initClass()"},
	 { "new_SoTextureCoordinateCylinder", _wrap_new_SoTextureCoordinateCylinder, METH_NOARGS, "new_SoTextureCoordinateCylinder() -> SoTextureCoordinateCylinder"},
	 { "SoTextureCoordinateCylinder_doAction", _wrap_SoTextureCoordinateCylinder_doAction, METH_VARARGS, "SoTextureCoordinateCylinder_doAction(SoTextureCoordinateCylinder self, SoAction action)"},
	 { "SoTextureCoordinateCylinder_GLRender", _wrap_SoTextureCoordinateCylinder_GLRender, METH_VARARGS, "SoTextureCoordinateCylinder_GLRender(SoTextureCoordinateCylinder self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateCylinder_callback", _wrap_SoTextureCoordinateCylinder_callback, METH_VARARGS, "SoTextureCoordinateCylinder_callback(SoTextureCoordinateCylinder self, SoCallbackAction action)"},
	 { "SoTextureCoordinateCylinder_pick", _wrap_SoTextureCoordinateCylinder_pick, METH_VARARGS, "SoTextureCoordinateCylinder_pick(SoTextureCoordinateCylinder self, SoPickAction action)"},
	 { "SoTextureCoordinateCylinder_swigregister", SoTextureCoordinateCylinder_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateCylinder_swiginit", SoTextureCoordinateCylinder_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCubeMap_getClassTypeId", _wrap_SoTextureCubeMap_getClassTypeId, METH_NOARGS, "SoTextureCubeMap_getClassTypeId() -> SoType"},
	 { "SoTextureCubeMap_getTypeId", _wrap_SoTextureCubeMap_getTypeId, METH_O, "SoTextureCubeMap_getTypeId(SoTextureCubeMap self) -> SoType"},
	 { "SoTextureCubeMap_initClass", _wrap_SoTextureCubeMap_initClass, METH_NOARGS, "SoTextureCubeMap_initClass()"},
	 { "new_SoTextureCubeMap", _wrap_new_SoTextureCubeMap, METH_NOARGS, "new_SoTextureCubeMap() -> SoTextureCubeMap"},
	 { "SoTextureCubeMap_filenames_set", _wrap_SoTextureCubeMap_filenames_set, METH_VARARGS, "SoTextureCubeMap_filenames_set(SoTextureCubeMap self, SoMFString filenames)"},
	 { "SoTextureCubeMap_filenames_get", _wrap_SoTextureCubeMap_filenames_get, METH_O, "SoTextureCubeMap_filenames_get(SoTextureCubeMap self) -> SoMFString"},
	 { "SoTextureCubeMap_imagePosX_set", _wrap_SoTextureCubeMap_imagePosX_set, METH_VARARGS, "SoTextureCubeMap_imagePosX_set(SoTextureCubeMap self, SoSFImage imagePosX)"},
	 { "SoTextureCubeMap_imagePosX_get", _wrap_SoTextureCubeMap_imagePosX_get, METH_O, "SoTextureCubeMap_imagePosX_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_imageNegX_set", _wrap_SoTextureCubeMap_imageNegX_set, METH_VARARGS, "SoTextureCubeMap_imageNegX_set(SoTextureCubeMap self, SoSFImage imageNegX)"},
	 { "SoTextureCubeMap_imageNegX_get", _wrap_SoTextureCubeMap_imageNegX_get, METH_O, "SoTextureCubeMap_imageNegX_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_imagePosY_set", _wrap_SoTextureCubeMap_imagePosY_set, METH_VARARGS, "SoTextureCubeMap_imagePosY_set(SoTextureCubeMap self, SoSFImage imagePosY)"},
	 { "SoTextureCubeMap_imagePosY_get", _wrap_SoTextureCubeMap_imagePosY_get, METH_O, "SoTextureCubeMap_imagePosY_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_imageNegY_set", _wrap_SoTextureCubeMap_imageNegY_set, METH_VARARGS, "SoTextureCubeMap_imageNegY_set(SoTextureCubeMap self, SoSFImage imageNegY)"},
	 { "SoTextureCubeMap_imageNegY_get", _wrap_SoTextureCubeMap_imageNegY_get, METH_O, "SoTextureCubeMap_imageNegY_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_imagePosZ_set", _wrap_SoTextureCubeMap_imagePosZ_set, METH_VARARGS, "SoTextureCubeMap_imagePosZ_set(SoTextureCubeMap self, SoSFImage imagePosZ)"},
	 { "SoTextureCubeMap_imagePosZ_get", _wrap_SoTextureCubeMap_imagePosZ_get, METH_O, "SoTextureCubeMap_imagePosZ_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_imageNegZ_set", _wrap_SoTextureCubeMap_imageNegZ_set, METH_VARARGS, "SoTextureCubeMap_imageNegZ_set(SoTextureCubeMap self, SoSFImage imageNegZ)"},
	 { "SoTextureCubeMap_imageNegZ_get", _wrap_SoTextureCubeMap_imageNegZ_get, METH_O, "SoTextureCubeMap_imageNegZ_get(SoTextureCubeMap self) -> SoSFImage"},
	 { "SoTextureCubeMap_wrapS_set", _wrap_SoTextureCubeMap_wrapS_set, METH_VARARGS, "SoTextureCubeMap_wrapS_set(SoTextureCubeMap self, SoSFEnum wrapS)"},
	 { "SoTextureCubeMap_wrapS_get", _wrap_SoTextureCubeMap_wrapS_get, METH_O, "SoTextureCubeMap_wrapS_get(SoTextureCubeMap self) -> SoSFEnum"},
	 { "SoTextureCubeMap_wrapT_set", _wrap_SoTextureCubeMap_wrapT_set, METH_VARARGS, "SoTextureCubeMap_wrapT_set(SoTextureCubeMap self, SoSFEnum wrapT)"},
	 { "SoTextureCubeMap_wrapT_get", _wrap_SoTextureCubeMap_wrapT_get, METH_O, "SoTextureCubeMap_wrapT_get(SoTextureCubeMap self) -> SoSFEnum"},
	 { "SoTextureCubeMap_model_set", _wrap_SoTextureCubeMap_model_set, METH_VARARGS, "SoTextureCubeMap_model_set(SoTextureCubeMap self, SoSFEnum model)"},
	 { "SoTextureCubeMap_model_get", _wrap_SoTextureCubeMap_model_get, METH_O, "SoTextureCubeMap_model_get(SoTextureCubeMap self) -> SoSFEnum"},
	 { "SoTextureCubeMap_blendColor_set", _wrap_SoTextureCubeMap_blendColor_set, METH_VARARGS, "SoTextureCubeMap_blendColor_set(SoTextureCubeMap self, SoSFColor blendColor)"},
	 { "SoTextureCubeMap_blendColor_get", _wrap_SoTextureCubeMap_blendColor_get, METH_O, "SoTextureCubeMap_blendColor_get(SoTextureCubeMap self) -> SoSFColor"},
	 { "SoTextureCubeMap_doAction", _wrap_SoTextureCubeMap_doAction, METH_VARARGS, "SoTextureCubeMap_doAction(SoTextureCubeMap self, SoAction action)"},
	 { "SoTextureCubeMap_GLRender", _wrap_SoTextureCubeMap_GLRender, METH_VARARGS, "SoTextureCubeMap_GLRender(SoTextureCubeMap self, SoGLRenderAction action)"},
	 { "SoTextureCubeMap_callback", _wrap_SoTextureCubeMap_callback, METH_VARARGS, "SoTextureCubeMap_callback(SoTextureCubeMap self, SoCallbackAction action)"},
	 { "SoTextureCubeMap_rayPick", _wrap_SoTextureCubeMap_rayPick, METH_VARARGS, "SoTextureCubeMap_rayPick(SoTextureCubeMap self, SoRayPickAction action)"},
	 { "SoTextureCubeMap_readImage", _wrap_SoTextureCubeMap_readImage, METH_VARARGS, "SoTextureCubeMap_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"},
	 { "SoTextureCubeMap_swigregister", SoTextureCubeMap_swigregister, METH_O, NULL},
	 { "SoTextureCubeMap_swiginit", SoTextureCubeMap_swiginit, METH_VARARGS, NULL},
	 { "SoShaderObject_getClassTypeId", _wrap_SoShaderObject_getClassTypeId, METH_NOARGS, "SoShaderObject_getClassTypeId() -> SoType"},
	 { "SoShaderObject_getTypeId", _wrap_SoShaderObject_getTypeId, METH_O, "SoShaderObject_getTypeId(SoShaderObject self) -> SoType"},
	 { "SoShaderObject_isActive_set", _wrap_SoShaderObject_isActive_set, METH_VARARGS, "SoShaderObject_isActive_set(SoShaderObject self, SoSFBool isActive)"},
	 { "SoShaderObject_isActive_get", _wrap_SoShaderObject_isActive_get, METH_O, "SoShaderObject_isActive_get(SoShaderObject self) -> SoSFBool"},
	 { "SoShaderObject_sourceType_set", _wrap_SoShaderObject_sourceType_set, METH_VARARGS, "SoShaderObject_sourceType_set(SoShaderObject self, SoSFEnum sourceType)"},
	 { "SoShaderObject_sourceType_get", _wrap_SoShaderObject_sourceType_get, METH_O, "SoShaderObject_sourceType_get(SoShaderObject self) -> SoSFEnum"},
	 { "SoShaderObject_sourceProgram_set", _wrap_SoShaderObject_sourceProgram_set, METH_VARARGS, "SoShaderObject_sourceProgram_set(SoShaderObject self, SoSFString sourceProgram)"},
	 { "SoShaderObject_sourceProgram_get", _wrap_SoShaderObject_sourceProgram_get, METH_O, "SoShaderObject_sourceProgram_get(SoShaderObject self) -> SoSFString"},
	 { "SoShaderObject_parameter_set", _wrap_SoShaderObject_parameter_set, METH_VARARGS, "SoShaderObject_parameter_set(SoShaderObject self, SoMFNode parameter)"},
	 { "SoShaderObject_parameter_get", _wrap_SoShaderObject_parameter_get, METH_O, "SoShaderObject_parameter_get(SoShaderObject self) -> SoMFNode"},
	 { "SoShaderObject_initClass", _wrap_SoShaderObject_initClass, METH_NOARGS, "SoShaderObject_initClass()"},
	 { "SoShaderObject_GLRender", _wrap_SoShaderObject_GLRender, METH_VARARGS, "SoShaderObject_GLRender(SoShaderObject self, SoGLRenderAction action)"},
	 { "SoShaderObject_search", _wrap_SoShaderObject_search, METH_VARARGS, "SoShaderObject_search(SoShaderObject self, SoSearchAction action)"},
	 { "SoShaderObject_render", _wrap_SoShaderObject_render, METH_VARARGS, "SoShaderObject_render(SoShaderObject self, SoState state)"},
	 { "SoShaderObject_updateParameters", _wrap_SoShaderObject_updateParameters, METH_VARARGS, "SoShaderObject_updateParameters(SoShaderObject self, SoState state)"},
	 { "SoShaderObject_getSourceType", _wrap_SoShaderObject_getSourceType, METH_O, "SoShaderObject_getSourceType(SoShaderObject self) -> SoShaderObject::SourceType"},
	 { "SoShaderObject_getSourceProgram", _wrap_SoShaderObject_getSourceProgram, METH_O, "SoShaderObject_getSourceProgram(SoShaderObject self) -> SbString"},
	 { "SoShaderObject_swigregister", SoShaderObject_swigregister, METH_O, NULL},
	 { "SoShaderParameter_getClassTypeId", _wrap_SoShaderParameter_getClassTypeId, METH_NOARGS, "SoShaderParameter_getClassTypeId() -> SoType"},
	 { "SoShaderParameter_getTypeId", _wrap_SoShaderParameter_getTypeId, METH_O, "SoShaderParameter_getTypeId(SoShaderParameter self) -> SoType"},
	 { "SoShaderParameter_name_set", _wrap_SoShaderParameter_name_set, METH_VARARGS, "SoShaderParameter_name_set(SoShaderParameter self, SoSFString name)"},
	 { "SoShaderParameter_name_get", _wrap_SoShaderParameter_name_get, METH_O, "SoShaderParameter_name_get(SoShaderParameter self) -> SoSFString"},
	 { "SoShaderParameter_identifier_set", _wrap_SoShaderParameter_identifier_set, METH_VARARGS, "SoShaderParameter_identifier_set(SoShaderParameter self, SoSFInt32 identifier)"},
	 { "SoShaderParameter_identifier_get", _wrap_SoShaderParameter_identifier_get, METH_O, "SoShaderParameter_identifier_get(SoShaderParameter self) -> SoSFInt32"},
	 { "SoShaderParameter_initClass", _wrap_SoShaderParameter_initClass, METH_NOARGS, "SoShaderParameter_initClass()"},
	 { "SoShaderParameter_swigregister", SoShaderParameter_swigregister, METH_O, NULL},
	 { "SoUniformShaderParameter_getClassTypeId", _wrap_SoUniformShaderParameter_getClassTypeId, METH_NOARGS, "SoUniformShaderParameter_getClassTypeId() -> SoType"},
	 { "SoUniformShaderParameter_getTypeId", _wrap_SoUniformShaderParameter_getTypeId, METH_O, "SoUniformShaderParameter_getTypeId(SoUniformShaderParameter self) -> SoType"},
	 { "SoUniformShaderParameter_initClass", _wrap_SoUniformShaderParameter_initClass, METH_NOARGS, "SoUniformShaderParameter_initClass()"},
	 { "SoUniformShaderParameter_updateParameter", _wrap_SoUniformShaderParameter_updateParameter, METH_VARARGS, "SoUniformShaderParameter_updateParameter(SoUniformShaderParameter self, SoGLShaderObject * shaderObject)"},
	 { "SoUniformShaderParameter_swigregister", SoUniformShaderParameter_swigregister, METH_O, NULL},
	 { "SoShaderParameter1f_getClassTypeId", _wrap_SoShaderParameter1f_getClassTypeId, METH_NOARGS, "SoShaderParameter1f_getClassTypeId() -> SoType"},
	 { "SoShaderParameter1f_getTypeId", _wrap_SoShaderParameter1f_getTypeId, METH_O, "SoShaderParameter1f_getTypeId(SoShaderParameter1f self) -> SoType"},
	 { "SoShaderParameter1f_value_set", _wrap_SoShaderParameter1f_value_set, METH_VARARGS, "SoShaderParameter1f_value_set(SoShaderParameter1f self, SoSFFloat value)"},
	 { "SoShaderParameter1f_value_get", _wrap_SoShaderParameter1f_value_get, METH_O, "SoShaderParameter1f_value_get(SoShaderParameter1f self) -> SoSFFloat"},
	 { "new_SoShaderParameter1f", _wrap_new_SoShaderParameter1f, METH_NOARGS, "new_SoShaderParameter1f() -> SoShaderParameter1f"},
	 { "SoShaderParameter1f_initClass", _wrap_SoShaderParameter1f_initClass, METH_NOARGS, "SoShaderParameter1f_initClass()"},
	 { "SoShaderParameter1f_updateParameter", _wrap_SoShaderParameter1f_updateParameter, METH_VARARGS, "SoShaderParameter1f_updateParameter(SoShaderParameter1f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter1f_swigregister", SoShaderParameter1f_swigregister, METH_O, NULL},
	 { "SoShaderParameter1f_swiginit", SoShaderParameter1f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter1i_getClassTypeId", _wrap_SoShaderParameter1i_getClassTypeId, METH_NOARGS, "SoShaderParameter1i_getClassTypeId() -> SoType"},
	 { "SoShaderParameter1i_getTypeId", _wrap_SoShaderParameter1i_getTypeId, METH_O, "SoShaderParameter1i_getTypeId(SoShaderParameter1i self) -> SoType"},
	 { "SoShaderParameter1i_value_set", _wrap_SoShaderParameter1i_value_set, METH_VARARGS, "SoShaderParameter1i_value_set(SoShaderParameter1i self, SoSFInt32 value)"},
	 { "SoShaderParameter1i_value_get", _wrap_SoShaderParameter1i_value_get, METH_O, "SoShaderParameter1i_value_get(SoShaderParameter1i self) -> SoSFInt32"},
	 { "new_SoShaderParameter1i", _wrap_new_SoShaderParameter1i, METH_NOARGS, "new_SoShaderParameter1i() -> SoShaderParameter1i"},
	 { "SoShaderParameter1i_initClass", _wrap_SoShaderParameter1i_initClass, METH_NOARGS, "SoShaderParameter1i_initClass()"},
	 { "SoShaderParameter1i_updateParameter", _wrap_SoShaderParameter1i_updateParameter, METH_VARARGS, "SoShaderParameter1i_updateParameter(SoShaderParameter1i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter1i_swigregister", SoShaderParameter1i_swigregister, METH_O, NULL},
	 { "SoShaderParameter1i_swiginit", SoShaderParameter1i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter2f_getClassTypeId", _wrap_SoShaderParameter2f_getClassTypeId, METH_NOARGS, "SoShaderParameter2f_getClassTypeId() -> SoType"},
	 { "SoShaderParameter2f_getTypeId", _wrap_SoShaderParameter2f_getTypeId, METH_O, "SoShaderParameter2f_getTypeId(SoShaderParameter2f self) -> SoType"},
	 { "SoShaderParameter2f_value_set", _wrap_SoShaderParameter2f_value_set, METH_VARARGS, "SoShaderParameter2f_value_set(SoShaderParameter2f self, SoSFVec2f value)"},
	 { "SoShaderParameter2f_value_get", _wrap_SoShaderParameter2f_value_get, METH_O, "SoShaderParameter2f_value_get(SoShaderParameter2f self) -> SoSFVec2f"},
	 { "new_SoShaderParameter2f", _wrap_new_SoShaderParameter2f, METH_NOARGS, "new_SoShaderParameter2f() -> SoShaderParameter2f"},
	 { "SoShaderParameter2f_initClass", _wrap_SoShaderParameter2f_initClass, METH_NOARGS, "SoShaderParameter2f_initClass()"},
	 { "SoShaderParameter2f_updateParameter", _wrap_SoShaderParameter2f_updateParameter, METH_VARARGS, "SoShaderParameter2f_updateParameter(SoShaderParameter2f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter2f_swigregister", SoShaderParameter2f_swigregister, METH_O, NULL},
	 { "SoShaderParameter2f_swiginit", SoShaderParameter2f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter2i_getClassTypeId", _wrap_SoShaderParameter2i_getClassTypeId, METH_NOARGS, "SoShaderParameter2i_getClassTypeId() -> SoType"},
	 { "SoShaderParameter2i_getTypeId", _wrap_SoShaderParameter2i_getTypeId, METH_O, "SoShaderParameter2i_getTypeId(SoShaderParameter2i self) -> SoType"},
	 { "SoShaderParameter2i_value_set", _wrap_SoShaderParameter2i_value_set, METH_VARARGS, "SoShaderParameter2i_value_set(SoShaderParameter2i self, SoSFVec2i32 value)"},
	 { "SoShaderParameter2i_value_get", _wrap_SoShaderParameter2i_value_get, METH_O, "SoShaderParameter2i_value_get(SoShaderParameter2i self) -> SoSFVec2i32"},
	 { "new_SoShaderParameter2i", _wrap_new_SoShaderParameter2i, METH_NOARGS, "new_SoShaderParameter2i() -> SoShaderParameter2i"},
	 { "SoShaderParameter2i_initClass", _wrap_SoShaderParameter2i_initClass, METH_NOARGS, "SoShaderParameter2i_initClass()"},
	 { "SoShaderParameter2i_updateParameter", _wrap_SoShaderParameter2i_updateParameter, METH_VARARGS, "SoShaderParameter2i_updateParameter(SoShaderParameter2i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter2i_swigregister", SoShaderParameter2i_swigregister, METH_O, NULL},
	 { "SoShaderParameter2i_swiginit", SoShaderParameter2i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter3f_getClassTypeId", _wrap_SoShaderParameter3f_getClassTypeId, METH_NOARGS, "SoShaderParameter3f_getClassTypeId() -> SoType"},
	 { "SoShaderParameter3f_getTypeId", _wrap_SoShaderParameter3f_getTypeId, METH_O, "SoShaderParameter3f_getTypeId(SoShaderParameter3f self) -> SoType"},
	 { "SoShaderParameter3f_value_set", _wrap_SoShaderParameter3f_value_set, METH_VARARGS, "SoShaderParameter3f_value_set(SoShaderParameter3f self, SoSFVec3f value)"},
	 { "SoShaderParameter3f_value_get", _wrap_SoShaderParameter3f_value_get, METH_O, "SoShaderParameter3f_value_get(SoShaderParameter3f self) -> SoSFVec3f"},
	 { "new_SoShaderParameter3f", _wrap_new_SoShaderParameter3f, METH_NOARGS, "new_SoShaderParameter3f() -> SoShaderParameter3f"},
	 { "SoShaderParameter3f_initClass", _wrap_SoShaderParameter3f_initClass, METH_NOARGS, "SoShaderParameter3f_initClass()"},
	 { "SoShaderParameter3f_updateParameter", _wrap_SoShaderParameter3f_updateParameter, METH_VARARGS, "SoShaderParameter3f_updateParameter(SoShaderParameter3f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter3f_swigregister", SoShaderParameter3f_swigregister, METH_O, NULL},
	 { "SoShaderParameter3f_swiginit", SoShaderParameter3f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter3i_getClassTypeId", _wrap_SoShaderParameter3i_getClassTypeId, METH_NOARGS, "SoShaderParameter3i_getClassTypeId() -> SoType"},
	 { "SoShaderParameter3i_getTypeId", _wrap_SoShaderParameter3i_getTypeId, METH_O, "SoShaderParameter3i_getTypeId(SoShaderParameter3i self) -> SoType"},
	 { "SoShaderParameter3i_value_set", _wrap_SoShaderParameter3i_value_set, METH_VARARGS, "SoShaderParameter3i_value_set(SoShaderParameter3i self, SoSFVec3i32 value)"},
	 { "SoShaderParameter3i_value_get", _wrap_SoShaderParameter3i_value_get, METH_O, "SoShaderParameter3i_value_get(SoShaderParameter3i self) -> SoSFVec3i32"},
	 { "new_SoShaderParameter3i", _wrap_new_SoShaderParameter3i, METH_NOARGS, "new_SoShaderParameter3i() -> SoShaderParameter3i"},
	 { "SoShaderParameter3i_initClass", _wrap_SoShaderParameter3i_initClass, METH_NOARGS, "SoShaderParameter3i_initClass()"},
	 { "SoShaderParameter3i_updateParameter", _wrap_SoShaderParameter3i_updateParameter, METH_VARARGS, "SoShaderParameter3i_updateParameter(SoShaderParameter3i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter3i_swigregister", SoShaderParameter3i_swigregister, METH_O, NULL},
	 { "SoShaderParameter3i_swiginit", SoShaderParameter3i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter4f_getClassTypeId", _wrap_SoShaderParameter4f_getClassTypeId, METH_NOARGS, "SoShaderParameter4f_getClassTypeId() -> SoType"},
	 { "SoShaderParameter4f_getTypeId", _wrap_SoShaderParameter4f_getTypeId, METH_O, "SoShaderParameter4f_getTypeId(SoShaderParameter4f self) -> SoType"},
	 { "SoShaderParameter4f_value_set", _wrap_SoShaderParameter4f_value_set, METH_VARARGS, "SoShaderParameter4f_value_set(SoShaderParameter4f self, SoSFVec4f value)"},
	 { "SoShaderParameter4f_value_get", _wrap_SoShaderParameter4f_value_get, METH_O, "SoShaderParameter4f_value_get(SoShaderParameter4f self) -> SoSFVec4f"},
	 { "new_SoShaderParameter4f", _wrap_new_SoShaderParameter4f, METH_NOARGS, "new_SoShaderParameter4f() -> SoShaderParameter4f"},
	 { "SoShaderParameter4f_initClass", _wrap_SoShaderParameter4f_initClass, METH_NOARGS, "SoShaderParameter4f_initClass()"},
	 { "SoShaderParameter4f_updateParameter", _wrap_SoShaderParameter4f_updateParameter, METH_VARARGS, "SoShaderParameter4f_updateParameter(SoShaderParameter4f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter4f_swigregister", SoShaderParameter4f_swigregister, METH_O, NULL},
	 { "SoShaderParameter4f_swiginit", SoShaderParameter4f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameter4i_getClassTypeId", _wrap_SoShaderParameter4i_getClassTypeId, METH_NOARGS, "SoShaderParameter4i_getClassTypeId() -> SoType"},
	 { "SoShaderParameter4i_getTypeId", _wrap_SoShaderParameter4i_getTypeId, METH_O, "SoShaderParameter4i_getTypeId(SoShaderParameter4i self) -> SoType"},
	 { "SoShaderParameter4i_value_set", _wrap_SoShaderParameter4i_value_set, METH_VARARGS, "SoShaderParameter4i_value_set(SoShaderParameter4i self, SoSFVec4i32 value)"},
	 { "SoShaderParameter4i_value_get", _wrap_SoShaderParameter4i_value_get, METH_O, "SoShaderParameter4i_value_get(SoShaderParameter4i self) -> SoSFVec4i32"},
	 { "new_SoShaderParameter4i", _wrap_new_SoShaderParameter4i, METH_NOARGS, "new_SoShaderParameter4i() -> SoShaderParameter4i"},
	 { "SoShaderParameter4i_initClass", _wrap_SoShaderParameter4i_initClass, METH_NOARGS, "SoShaderParameter4i_initClass()"},
	 { "SoShaderParameter4i_updateParameter", _wrap_SoShaderParameter4i_updateParameter, METH_VARARGS, "SoShaderParameter4i_updateParameter(SoShaderParameter4i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameter4i_swigregister", SoShaderParameter4i_swigregister, METH_O, NULL},
	 { "SoShaderParameter4i_swiginit", SoShaderParameter4i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray1f_getClassTypeId", _wrap_SoShaderParameterArray1f_getClassTypeId, METH_NOARGS, "SoShaderParameterArray1f_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray1f_getTypeId", _wrap_SoShaderParameterArray1f_getTypeId, METH_O, "SoShaderParameterArray1f_getTypeId(SoShaderParameterArray1f self) -> SoType"},
	 { "SoShaderParameterArray1f_value_set", _wrap_SoShaderParameterArray1f_value_set, METH_VARARGS, "SoShaderParameterArray1f_value_set(SoShaderParameterArray1f self, SoMFFloat value)"},
	 { "SoShaderParameterArray1f_value_get", _wrap_SoShaderParameterArray1f_value_get, METH_O, "SoShaderParameterArray1f_value_get(SoShaderParameterArray1f self) -> SoMFFloat"},
	 { "new_SoShaderParameterArray1f", _wrap_new_SoShaderParameterArray1f, METH_NOARGS, "new_SoShaderParameterArray1f() -> SoShaderParameterArray1f"},
	 { "SoShaderParameterArray1f_initClass", _wrap_SoShaderParameterArray1f_initClass, METH_NOARGS, "SoShaderParameterArray1f_initClass()"},
	 { "SoShaderParameterArray1f_updateParameter", _wrap_SoShaderParameterArray1f_updateParameter, METH_VARARGS, "SoShaderParameterArray1f_updateParameter(SoShaderParameterArray1f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray1f_swigregister", SoShaderParameterArray1f_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray1f_swiginit", SoShaderParameterArray1f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray1i_getClassTypeId", _wrap_SoShaderParameterArray1i_getClassTypeId, METH_NOARGS, "SoShaderParameterArray1i_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray1i_getTypeId", _wrap_SoShaderParameterArray1i_getTypeId, METH_O, "SoShaderParameterArray1i_getTypeId(SoShaderParameterArray1i self) -> SoType"},
	 { "SoShaderParameterArray1i_value_set", _wrap_SoShaderParameterArray1i_value_set, METH_VARARGS, "SoShaderParameterArray1i_value_set(SoShaderParameterArray1i self, SoMFInt32 value)"},
	 { "SoShaderParameterArray1i_value_get", _wrap_SoShaderParameterArray1i_value_get, METH_O, "SoShaderParameterArray1i_value_get(SoShaderParameterArray1i self) -> SoMFInt32"},
	 { "new_SoShaderParameterArray1i", _wrap_new_SoShaderParameterArray1i, METH_NOARGS, "new_SoShaderParameterArray1i() -> SoShaderParameterArray1i"},
	 { "SoShaderParameterArray1i_initClass", _wrap_SoShaderParameterArray1i_initClass, METH_NOARGS, "SoShaderParameterArray1i_initClass()"},
	 { "SoShaderParameterArray1i_updateParameter", _wrap_SoShaderParameterArray1i_updateParameter, METH_VARARGS, "SoShaderParameterArray1i_updateParameter(SoShaderParameterArray1i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray1i_swigregister", SoShaderParameterArray1i_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray1i_swiginit", SoShaderParameterArray1i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray2f_getClassTypeId", _wrap_SoShaderParameterArray2f_getClassTypeId, METH_NOARGS, "SoShaderParameterArray2f_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray2f_getTypeId", _wrap_SoShaderParameterArray2f_getTypeId, METH_O, "SoShaderParameterArray2f_getTypeId(SoShaderParameterArray2f self) -> SoType"},
	 { "SoShaderParameterArray2f_value_set", _wrap_SoShaderParameterArray2f_value_set, METH_VARARGS, "SoShaderParameterArray2f_value_set(SoShaderParameterArray2f self, SoMFVec2f value)"},
	 { "SoShaderParameterArray2f_value_get", _wrap_SoShaderParameterArray2f_value_get, METH_O, "SoShaderParameterArray2f_value_get(SoShaderParameterArray2f self) -> SoMFVec2f"},
	 { "new_SoShaderParameterArray2f", _wrap_new_SoShaderParameterArray2f, METH_NOARGS, "new_SoShaderParameterArray2f() -> SoShaderParameterArray2f"},
	 { "SoShaderParameterArray2f_initClass", _wrap_SoShaderParameterArray2f_initClass, METH_NOARGS, "SoShaderParameterArray2f_initClass()"},
	 { "SoShaderParameterArray2f_updateParameter", _wrap_SoShaderParameterArray2f_updateParameter, METH_VARARGS, "SoShaderParameterArray2f_updateParameter(SoShaderParameterArray2f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray2f_swigregister", SoShaderParameterArray2f_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray2f_swiginit", SoShaderParameterArray2f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray2i_getClassTypeId", _wrap_SoShaderParameterArray2i_getClassTypeId, METH_NOARGS, "SoShaderParameterArray2i_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray2i_getTypeId", _wrap_SoShaderParameterArray2i_getTypeId, METH_O, "SoShaderParameterArray2i_getTypeId(SoShaderParameterArray2i self) -> SoType"},
	 { "SoShaderParameterArray2i_value_set", _wrap_SoShaderParameterArray2i_value_set, METH_VARARGS, "SoShaderParameterArray2i_value_set(SoShaderParameterArray2i self, SoMFVec2i32 value)"},
	 { "SoShaderParameterArray2i_value_get", _wrap_SoShaderParameterArray2i_value_get, METH_O, "SoShaderParameterArray2i_value_get(SoShaderParameterArray2i self) -> SoMFVec2i32"},
	 { "new_SoShaderParameterArray2i", _wrap_new_SoShaderParameterArray2i, METH_NOARGS, "new_SoShaderParameterArray2i() -> SoShaderParameterArray2i"},
	 { "SoShaderParameterArray2i_initClass", _wrap_SoShaderParameterArray2i_initClass, METH_NOARGS, "SoShaderParameterArray2i_initClass()"},
	 { "SoShaderParameterArray2i_updateParameter", _wrap_SoShaderParameterArray2i_updateParameter, METH_VARARGS, "SoShaderParameterArray2i_updateParameter(SoShaderParameterArray2i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray2i_swigregister", SoShaderParameterArray2i_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray2i_swiginit", SoShaderParameterArray2i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray3f_getClassTypeId", _wrap_SoShaderParameterArray3f_getClassTypeId, METH_NOARGS, "SoShaderParameterArray3f_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray3f_getTypeId", _wrap_SoShaderParameterArray3f_getTypeId, METH_O, "SoShaderParameterArray3f_getTypeId(SoShaderParameterArray3f self) -> SoType"},
	 { "SoShaderParameterArray3f_value_set", _wrap_SoShaderParameterArray3f_value_set, METH_VARARGS, "SoShaderParameterArray3f_value_set(SoShaderParameterArray3f self, SoMFVec3f value)"},
	 { "SoShaderParameterArray3f_value_get", _wrap_SoShaderParameterArray3f_value_get, METH_O, "SoShaderParameterArray3f_value_get(SoShaderParameterArray3f self) -> SoMFVec3f"},
	 { "new_SoShaderParameterArray3f", _wrap_new_SoShaderParameterArray3f, METH_NOARGS, "new_SoShaderParameterArray3f() -> SoShaderParameterArray3f"},
	 { "SoShaderParameterArray3f_initClass", _wrap_SoShaderParameterArray3f_initClass, METH_NOARGS, "SoShaderParameterArray3f_initClass()"},
	 { "SoShaderParameterArray3f_updateParameter", _wrap_SoShaderParameterArray3f_updateParameter, METH_VARARGS, "SoShaderParameterArray3f_updateParameter(SoShaderParameterArray3f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray3f_swigregister", SoShaderParameterArray3f_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray3f_swiginit", SoShaderParameterArray3f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray3i_getClassTypeId", _wrap_SoShaderParameterArray3i_getClassTypeId, METH_NOARGS, "SoShaderParameterArray3i_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray3i_getTypeId", _wrap_SoShaderParameterArray3i_getTypeId, METH_O, "SoShaderParameterArray3i_getTypeId(SoShaderParameterArray3i self) -> SoType"},
	 { "SoShaderParameterArray3i_value_set", _wrap_SoShaderParameterArray3i_value_set, METH_VARARGS, "SoShaderParameterArray3i_value_set(SoShaderParameterArray3i self, SoMFVec3i32 value)"},
	 { "SoShaderParameterArray3i_value_get", _wrap_SoShaderParameterArray3i_value_get, METH_O, "SoShaderParameterArray3i_value_get(SoShaderParameterArray3i self) -> SoMFVec3i32"},
	 { "new_SoShaderParameterArray3i", _wrap_new_SoShaderParameterArray3i, METH_NOARGS, "new_SoShaderParameterArray3i() -> SoShaderParameterArray3i"},
	 { "SoShaderParameterArray3i_initClass", _wrap_SoShaderParameterArray3i_initClass, METH_NOARGS, "SoShaderParameterArray3i_initClass()"},
	 { "SoShaderParameterArray3i_updateParameter", _wrap_SoShaderParameterArray3i_updateParameter, METH_VARARGS, "SoShaderParameterArray3i_updateParameter(SoShaderParameterArray3i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray3i_swigregister", SoShaderParameterArray3i_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray3i_swiginit", SoShaderParameterArray3i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray4f_getClassTypeId", _wrap_SoShaderParameterArray4f_getClassTypeId, METH_NOARGS, "SoShaderParameterArray4f_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray4f_getTypeId", _wrap_SoShaderParameterArray4f_getTypeId, METH_O, "SoShaderParameterArray4f_getTypeId(SoShaderParameterArray4f self) -> SoType"},
	 { "SoShaderParameterArray4f_value_set", _wrap_SoShaderParameterArray4f_value_set, METH_VARARGS, "SoShaderParameterArray4f_value_set(SoShaderParameterArray4f self, SoMFVec4f value)"},
	 { "SoShaderParameterArray4f_value_get", _wrap_SoShaderParameterArray4f_value_get, METH_O, "SoShaderParameterArray4f_value_get(SoShaderParameterArray4f self) -> SoMFVec4f"},
	 { "new_SoShaderParameterArray4f", _wrap_new_SoShaderParameterArray4f, METH_NOARGS, "new_SoShaderParameterArray4f() -> SoShaderParameterArray4f"},
	 { "SoShaderParameterArray4f_initClass", _wrap_SoShaderParameterArray4f_initClass, METH_NOARGS, "SoShaderParameterArray4f_initClass()"},
	 { "SoShaderParameterArray4f_updateParameter", _wrap_SoShaderParameterArray4f_updateParameter, METH_VARARGS, "SoShaderParameterArray4f_updateParameter(SoShaderParameterArray4f self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray4f_swigregister", SoShaderParameterArray4f_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray4f_swiginit", SoShaderParameterArray4f_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterArray4i_getClassTypeId", _wrap_SoShaderParameterArray4i_getClassTypeId, METH_NOARGS, "SoShaderParameterArray4i_getClassTypeId() -> SoType"},
	 { "SoShaderParameterArray4i_getTypeId", _wrap_SoShaderParameterArray4i_getTypeId, METH_O, "SoShaderParameterArray4i_getTypeId(SoShaderParameterArray4i self) -> SoType"},
	 { "SoShaderParameterArray4i_value_set", _wrap_SoShaderParameterArray4i_value_set, METH_VARARGS, "SoShaderParameterArray4i_value_set(SoShaderParameterArray4i self, SoMFVec4i32 value)"},
	 { "SoShaderParameterArray4i_value_get", _wrap_SoShaderParameterArray4i_value_get, METH_O, "SoShaderParameterArray4i_value_get(SoShaderParameterArray4i self) -> SoMFVec4i32"},
	 { "new_SoShaderParameterArray4i", _wrap_new_SoShaderParameterArray4i, METH_NOARGS, "new_SoShaderParameterArray4i() -> SoShaderParameterArray4i"},
	 { "SoShaderParameterArray4i_initClass", _wrap_SoShaderParameterArray4i_initClass, METH_NOARGS, "SoShaderParameterArray4i_initClass()"},
	 { "SoShaderParameterArray4i_updateParameter", _wrap_SoShaderParameterArray4i_updateParameter, METH_VARARGS, "SoShaderParameterArray4i_updateParameter(SoShaderParameterArray4i self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterArray4i_swigregister", SoShaderParameterArray4i_swigregister, METH_O, NULL},
	 { "SoShaderParameterArray4i_swiginit", SoShaderParameterArray4i_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterMatrix_getClassTypeId", _wrap_SoShaderParameterMatrix_getClassTypeId, METH_NOARGS, "SoShaderParameterMatrix_getClassTypeId() -> SoType"},
	 { "SoShaderParameterMatrix_getTypeId", _wrap_SoShaderParameterMatrix_getTypeId, METH_O, "SoShaderParameterMatrix_getTypeId(SoShaderParameterMatrix self) -> SoType"},
	 { "SoShaderParameterMatrix_value_set", _wrap_SoShaderParameterMatrix_value_set, METH_VARARGS, "SoShaderParameterMatrix_value_set(SoShaderParameterMatrix self, SoSFMatrix value)"},
	 { "SoShaderParameterMatrix_value_get", _wrap_SoShaderParameterMatrix_value_get, METH_O, "SoShaderParameterMatrix_value_get(SoShaderParameterMatrix self) -> SoSFMatrix"},
	 { "new_SoShaderParameterMatrix", _wrap_new_SoShaderParameterMatrix, METH_NOARGS, "new_SoShaderParameterMatrix() -> SoShaderParameterMatrix"},
	 { "SoShaderParameterMatrix_initClass", _wrap_SoShaderParameterMatrix_initClass, METH_NOARGS, "SoShaderParameterMatrix_initClass()"},
	 { "SoShaderParameterMatrix_updateParameter", _wrap_SoShaderParameterMatrix_updateParameter, METH_VARARGS, "SoShaderParameterMatrix_updateParameter(SoShaderParameterMatrix self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterMatrix_swigregister", SoShaderParameterMatrix_swigregister, METH_O, NULL},
	 { "SoShaderParameterMatrix_swiginit", SoShaderParameterMatrix_swiginit, METH_VARARGS, NULL},
	 { "SoShaderParameterMatrixArray_getClassTypeId", _wrap_SoShaderParameterMatrixArray_getClassTypeId, METH_NOARGS, "SoShaderParameterMatrixArray_getClassTypeId() -> SoType"},
	 { "SoShaderParameterMatrixArray_getTypeId", _wrap_SoShaderParameterMatrixArray_getTypeId, METH_O, "SoShaderParameterMatrixArray_getTypeId(SoShaderParameterMatrixArray self) -> SoType"},
	 { "SoShaderParameterMatrixArray_value_set", _wrap_SoShaderParameterMatrixArray_value_set, METH_VARARGS, "SoShaderParameterMatrixArray_value_set(SoShaderParameterMatrixArray self, SoMFMatrix value)"},
	 { "SoShaderParameterMatrixArray_value_get", _wrap_SoShaderParameterMatrixArray_value_get, METH_O, "SoShaderParameterMatrixArray_value_get(SoShaderParameterMatrixArray self) -> SoMFMatrix"},
	 { "new_SoShaderParameterMatrixArray", _wrap_new_SoShaderParameterMatrixArray, METH_NOARGS, "new_SoShaderParameterMatrixArray() -> SoShaderParameterMatrixArray"},
	 { "SoShaderParameterMatrixArray_initClass", _wrap_SoShaderParameterMatrixArray_initClass, METH_NOARGS, "SoShaderParameterMatrixArray_initClass()"},
	 { "SoShaderParameterMatrixArray_updateParameter", _wrap_SoShaderParameterMatrixArray_updateParameter, METH_VARARGS, "SoShaderParameterMatrixArray_updateParameter(SoShaderParameterMatrixArray self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderParameterMatrixArray_swigregister", SoShaderParameterMatrixArray_swigregister, METH_O, NULL},
	 { "SoShaderParameterMatrixArray_swiginit", SoShaderParameterMatrixArray_swiginit, METH_VARARGS, NULL},
	 { "SoShaderStateMatrixParameter_getClassTypeId", _wrap_SoShaderStateMatrixParameter_getClassTypeId, METH_NOARGS, "SoShaderStateMatrixParameter_getClassTypeId() -> SoType"},
	 { "SoShaderStateMatrixParameter_getTypeId", _wrap_SoShaderStateMatrixParameter_getTypeId, METH_O, "SoShaderStateMatrixParameter_getTypeId(SoShaderStateMatrixParameter self) -> SoType"},
	 { "SoShaderStateMatrixParameter_matrixType_set", _wrap_SoShaderStateMatrixParameter_matrixType_set, METH_VARARGS, "SoShaderStateMatrixParameter_matrixType_set(SoShaderStateMatrixParameter self, SoSFEnum matrixType)"},
	 { "SoShaderStateMatrixParameter_matrixType_get", _wrap_SoShaderStateMatrixParameter_matrixType_get, METH_O, "SoShaderStateMatrixParameter_matrixType_get(SoShaderStateMatrixParameter self) -> SoSFEnum"},
	 { "SoShaderStateMatrixParameter_matrixTransform_set", _wrap_SoShaderStateMatrixParameter_matrixTransform_set, METH_VARARGS, "SoShaderStateMatrixParameter_matrixTransform_set(SoShaderStateMatrixParameter self, SoSFEnum matrixTransform)"},
	 { "SoShaderStateMatrixParameter_matrixTransform_get", _wrap_SoShaderStateMatrixParameter_matrixTransform_get, METH_O, "SoShaderStateMatrixParameter_matrixTransform_get(SoShaderStateMatrixParameter self) -> SoSFEnum"},
	 { "new_SoShaderStateMatrixParameter", _wrap_new_SoShaderStateMatrixParameter, METH_NOARGS, "new_SoShaderStateMatrixParameter() -> SoShaderStateMatrixParameter"},
	 { "delete_SoShaderStateMatrixParameter", _wrap_delete_SoShaderStateMatrixParameter, METH_O, "delete_SoShaderStateMatrixParameter(SoShaderStateMatrixParameter self)"},
	 { "SoShaderStateMatrixParameter_initClass", _wrap_SoShaderStateMatrixParameter_initClass, METH_NOARGS, "SoShaderStateMatrixParameter_initClass()"},
	 { "SoShaderStateMatrixParameter_updateParameter", _wrap_SoShaderStateMatrixParameter_updateParameter, METH_VARARGS, "SoShaderStateMatrixParameter_updateParameter(SoShaderStateMatrixParameter self, SoGLShaderObject * shaderObject)"},
	 { "SoShaderStateMatrixParameter_updateValue", _wrap_SoShaderStateMatrixParameter_updateValue, METH_VARARGS, "SoShaderStateMatrixParameter_updateValue(SoShaderStateMatrixParameter self, SoState state)"},
	 { "SoShaderStateMatrixParameter_swigregister", SoShaderStateMatrixParameter_swigregister, METH_O, NULL},
	 { "SoShaderStateMatrixParameter_swiginit", SoShaderStateMatrixParameter_swiginit, METH_VARARGS, NULL},
	 { "SoShaderProgram_getClassTypeId", _wrap_SoShaderProgram_getClassTypeId, METH_NOARGS, "SoShaderProgram_getClassTypeId() -> SoType"},
	 { "SoShaderProgram_getTypeId", _wrap_SoShaderProgram_getTypeId, METH_O, "SoShaderProgram_getTypeId(SoShaderProgram self) -> SoType"},
	 { "SoShaderProgram_shaderObject_set", _wrap_SoShaderProgram_shaderObject_set, METH_VARARGS, "SoShaderProgram_shaderObject_set(SoShaderProgram self, SoMFNode shaderObject)"},
	 { "SoShaderProgram_shaderObject_get", _wrap_SoShaderProgram_shaderObject_get, METH_O, "SoShaderProgram_shaderObject_get(SoShaderProgram self) -> SoMFNode"},
	 { "new_SoShaderProgram", _wrap_new_SoShaderProgram, METH_NOARGS, "new_SoShaderProgram() -> SoShaderProgram"},
	 { "SoShaderProgram_setEnableCallback", _wrap_SoShaderProgram_setEnableCallback, METH_VARARGS, "SoShaderProgram_setEnableCallback(SoShaderProgram self, SoShaderProgramEnableCB * cb, void * closure)"},
	 { "SoShaderProgram_GLRender", _wrap_SoShaderProgram_GLRender, METH_VARARGS, "SoShaderProgram_GLRender(SoShaderProgram self, SoGLRenderAction action)"},
	 { "SoShaderProgram_search", _wrap_SoShaderProgram_search, METH_VARARGS, "SoShaderProgram_search(SoShaderProgram self, SoSearchAction action)"},
	 { "SoShaderProgram_render", _wrap_SoShaderProgram_render, METH_VARARGS, "SoShaderProgram_render(SoShaderProgram self, SoState state)"},
	 { "SoShaderProgram_initClass", _wrap_SoShaderProgram_initClass, METH_NOARGS, "SoShaderProgram_initClass()"},
	 { "SoShaderProgram_swigregister", SoShaderProgram_swigregister, METH_O, NULL},
	 { "SoShaderProgram_swiginit", SoShaderProgram_swiginit, METH_VARARGS, NULL},
	 { "SoFragmentShader_getClassTypeId", _wrap_SoFragmentShader_getClassTypeId, METH_NOARGS, "SoFragmentShader_getClassTypeId() -> SoType"},
	 { "SoFragmentShader_getTypeId", _wrap_SoFragmentShader_getTypeId, METH_O, "SoFragmentShader_getTypeId(SoFragmentShader self) -> SoType"},
	 { "SoFragmentShader_initClass", _wrap_SoFragmentShader_initClass, METH_NOARGS, "SoFragmentShader_initClass()"},
	 { "new_SoFragmentShader", _wrap_new_SoFragmentShader, METH_NOARGS, "new_SoFragmentShader() -> SoFragmentShader"},
	 { "delete_SoFragmentShader", _wrap_delete_SoFragmentShader, METH_O, "delete_SoFragmentShader(SoFragmentShader self)"},
	 { "SoFragmentShader_isSupported", _wrap_SoFragmentShader_isSupported, METH_O, "SoFragmentShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"},
	 { "SoFragmentShader_swigregister", SoFragmentShader_swigregister, METH_O, NULL},
	 { "SoFragmentShader_swiginit", SoFragmentShader_swiginit, METH_VARARGS, NULL},
	 { "SoVertexShader_getClassTypeId", _wrap_SoVertexShader_getClassTypeId, METH_NOARGS, "SoVertexShader_getClassTypeId() -> SoType"},
	 { "SoVertexShader_getTypeId", _wrap_SoVertexShader_getTypeId, METH_O, "SoVertexShader_getTypeId(SoVertexShader self) -> SoType"},
	 { "SoVertexShader_initClass", _wrap_SoVertexShader_initClass, METH_NOARGS, "SoVertexShader_initClass()"},
	 { "new_SoVertexShader", _wrap_new_SoVertexShader, METH_NOARGS, "new_SoVertexShader() -> SoVertexShader"},
	 { "delete_SoVertexShader", _wrap_delete_SoVertexShader, METH_O, "delete_SoVertexShader(SoVertexShader self)"},
	 { "SoVertexShader_isSupported", _wrap_SoVertexShader_isSupported, METH_O, "SoVertexShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"},
	 { "SoVertexShader_swigregister", SoVertexShader_swigregister, METH_O, NULL},
	 { "SoVertexShader_swiginit", SoVertexShader_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateNormalMap_getClassTypeId", _wrap_SoTextureCoordinateNormalMap_getClassTypeId, METH_NOARGS, "SoTextureCoordinateNormalMap_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateNormalMap_getTypeId", _wrap_SoTextureCoordinateNormalMap_getTypeId, METH_O, "SoTextureCoordinateNormalMap_getTypeId(SoTextureCoordinateNormalMap self) -> SoType"},
	 { "SoTextureCoordinateNormalMap_initClass", _wrap_SoTextureCoordinateNormalMap_initClass, METH_NOARGS, "SoTextureCoordinateNormalMap_initClass()"},
	 { "new_SoTextureCoordinateNormalMap", _wrap_new_SoTextureCoordinateNormalMap, METH_NOARGS, "new_SoTextureCoordinateNormalMap() -> SoTextureCoordinateNormalMap"},
	 { "SoTextureCoordinateNormalMap_doAction", _wrap_SoTextureCoordinateNormalMap_doAction, METH_VARARGS, "SoTextureCoordinateNormalMap_doAction(SoTextureCoordinateNormalMap self, SoAction action)"},
	 { "SoTextureCoordinateNormalMap_GLRender", _wrap_SoTextureCoordinateNormalMap_GLRender, METH_VARARGS, "SoTextureCoordinateNormalMap_GLRender(SoTextureCoordinateNormalMap self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateNormalMap_pick", _wrap_SoTextureCoordinateNormalMap_pick, METH_VARARGS, "SoTextureCoordinateNormalMap_pick(SoTextureCoordinateNormalMap self, SoPickAction action)"},
	 { "SoTextureCoordinateNormalMap_callback", _wrap_SoTextureCoordinateNormalMap_callback, METH_VARARGS, "SoTextureCoordinateNormalMap_callback(SoTextureCoordinateNormalMap self, SoCallbackAction action)"},
	 { "SoTextureCoordinateNormalMap_swigregister", SoTextureCoordinateNormalMap_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateNormalMap_swiginit", SoTextureCoordinateNormalMap_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateReflectionMap_getClassTypeId", _wrap_SoTextureCoordinateReflectionMap_getClassTypeId, METH_NOARGS, "SoTextureCoordinateReflectionMap_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateReflectionMap_getTypeId", _wrap_SoTextureCoordinateReflectionMap_getTypeId, METH_O, "SoTextureCoordinateReflectionMap_getTypeId(SoTextureCoordinateReflectionMap self) -> SoType"},
	 { "SoTextureCoordinateReflectionMap_initClass", _wrap_SoTextureCoordinateReflectionMap_initClass, METH_NOARGS, "SoTextureCoordinateReflectionMap_initClass()"},
	 { "new_SoTextureCoordinateReflectionMap", _wrap_new_SoTextureCoordinateReflectionMap, METH_NOARGS, "new_SoTextureCoordinateReflectionMap() -> SoTextureCoordinateReflectionMap"},
	 { "SoTextureCoordinateReflectionMap_doAction", _wrap_SoTextureCoordinateReflectionMap_doAction, METH_VARARGS, "SoTextureCoordinateReflectionMap_doAction(SoTextureCoordinateReflectionMap self, SoAction action)"},
	 { "SoTextureCoordinateReflectionMap_GLRender", _wrap_SoTextureCoordinateReflectionMap_GLRender, METH_VARARGS, "SoTextureCoordinateReflectionMap_GLRender(SoTextureCoordinateReflectionMap self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateReflectionMap_pick", _wrap_SoTextureCoordinateReflectionMap_pick, METH_VARARGS, "SoTextureCoordinateReflectionMap_pick(SoTextureCoordinateReflectionMap self, SoPickAction action)"},
	 { "SoTextureCoordinateReflectionMap_callback", _wrap_SoTextureCoordinateReflectionMap_callback, METH_VARARGS, "SoTextureCoordinateReflectionMap_callback(SoTextureCoordinateReflectionMap self, SoCallbackAction action)"},
	 { "SoTextureCoordinateReflectionMap_swigregister", SoTextureCoordinateReflectionMap_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateReflectionMap_swiginit", SoTextureCoordinateReflectionMap_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCoordinateObject_getClassTypeId", _wrap_SoTextureCoordinateObject_getClassTypeId, METH_NOARGS, "SoTextureCoordinateObject_getClassTypeId() -> SoType"},
	 { "SoTextureCoordinateObject_getTypeId", _wrap_SoTextureCoordinateObject_getTypeId, METH_O, "SoTextureCoordinateObject_getTypeId(SoTextureCoordinateObject self) -> SoType"},
	 { "SoTextureCoordinateObject_initClass", _wrap_SoTextureCoordinateObject_initClass, METH_NOARGS, "SoTextureCoordinateObject_initClass()"},
	 { "new_SoTextureCoordinateObject", _wrap_new_SoTextureCoordinateObject, METH_NOARGS, "new_SoTextureCoordinateObject() -> SoTextureCoordinateObject"},
	 { "SoTextureCoordinateObject_factorS_set", _wrap_SoTextureCoordinateObject_factorS_set, METH_VARARGS, "SoTextureCoordinateObject_factorS_set(SoTextureCoordinateObject self, SoSFVec4f factorS)"},
	 { "SoTextureCoordinateObject_factorS_get", _wrap_SoTextureCoordinateObject_factorS_get, METH_O, "SoTextureCoordinateObject_factorS_get(SoTextureCoordinateObject self) -> SoSFVec4f"},
	 { "SoTextureCoordinateObject_factorT_set", _wrap_SoTextureCoordinateObject_factorT_set, METH_VARARGS, "SoTextureCoordinateObject_factorT_set(SoTextureCoordinateObject self, SoSFVec4f factorT)"},
	 { "SoTextureCoordinateObject_factorT_get", _wrap_SoTextureCoordinateObject_factorT_get, METH_O, "SoTextureCoordinateObject_factorT_get(SoTextureCoordinateObject self) -> SoSFVec4f"},
	 { "SoTextureCoordinateObject_factorR_set", _wrap_SoTextureCoordinateObject_factorR_set, METH_VARARGS, "SoTextureCoordinateObject_factorR_set(SoTextureCoordinateObject self, SoSFVec4f factorR)"},
	 { "SoTextureCoordinateObject_factorR_get", _wrap_SoTextureCoordinateObject_factorR_get, METH_O, "SoTextureCoordinateObject_factorR_get(SoTextureCoordinateObject self) -> SoSFVec4f"},
	 { "SoTextureCoordinateObject_factorQ_set", _wrap_SoTextureCoordinateObject_factorQ_set, METH_VARARGS, "SoTextureCoordinateObject_factorQ_set(SoTextureCoordinateObject self, SoSFVec4f factorQ)"},
	 { "SoTextureCoordinateObject_factorQ_get", _wrap_SoTextureCoordinateObject_factorQ_get, METH_O, "SoTextureCoordinateObject_factorQ_get(SoTextureCoordinateObject self) -> SoSFVec4f"},
	 { "SoTextureCoordinateObject_doAction", _wrap_SoTextureCoordinateObject_doAction, METH_VARARGS, "SoTextureCoordinateObject_doAction(SoTextureCoordinateObject self, SoAction action)"},
	 { "SoTextureCoordinateObject_GLRender", _wrap_SoTextureCoordinateObject_GLRender, METH_VARARGS, "SoTextureCoordinateObject_GLRender(SoTextureCoordinateObject self, SoGLRenderAction action)"},
	 { "SoTextureCoordinateObject_pick", _wrap_SoTextureCoordinateObject_pick, METH_VARARGS, "SoTextureCoordinateObject_pick(SoTextureCoordinateObject self, SoPickAction action)"},
	 { "SoTextureCoordinateObject_callback", _wrap_SoTextureCoordinateObject_callback, METH_VARARGS, "SoTextureCoordinateObject_callback(SoTextureCoordinateObject self, SoCallbackAction action)"},
	 { "SoTextureCoordinateObject_swigregister", SoTextureCoordinateObject_swigregister, METH_O, NULL},
	 { "SoTextureCoordinateObject_swiginit", SoTextureCoordinateObject_swiginit, METH_VARARGS, NULL},
	 { "SoTextureScalePolicy_getClassTypeId", _wrap_SoTextureScalePolicy_getClassTypeId, METH_NOARGS, "SoTextureScalePolicy_getClassTypeId() -> SoType"},
	 { "SoTextureScalePolicy_getTypeId", _wrap_SoTextureScalePolicy_getTypeId, METH_O, "SoTextureScalePolicy_getTypeId(SoTextureScalePolicy self) -> SoType"},
	 { "SoTextureScalePolicy_initClass", _wrap_SoTextureScalePolicy_initClass, METH_NOARGS, "SoTextureScalePolicy_initClass()"},
	 { "new_SoTextureScalePolicy", _wrap_new_SoTextureScalePolicy, METH_NOARGS, "new_SoTextureScalePolicy() -> SoTextureScalePolicy"},
	 { "SoTextureScalePolicy_policy_set", _wrap_SoTextureScalePolicy_policy_set, METH_VARARGS, "SoTextureScalePolicy_policy_set(SoTextureScalePolicy self, SoSFEnum policy)"},
	 { "SoTextureScalePolicy_policy_get", _wrap_SoTextureScalePolicy_policy_get, METH_O, "SoTextureScalePolicy_policy_get(SoTextureScalePolicy self) -> SoSFEnum"},
	 { "SoTextureScalePolicy_quality_set", _wrap_SoTextureScalePolicy_quality_set, METH_VARARGS, "SoTextureScalePolicy_quality_set(SoTextureScalePolicy self, SoSFFloat quality)"},
	 { "SoTextureScalePolicy_quality_get", _wrap_SoTextureScalePolicy_quality_get, METH_O, "SoTextureScalePolicy_quality_get(SoTextureScalePolicy self) -> SoSFFloat"},
	 { "SoTextureScalePolicy_GLRender", _wrap_SoTextureScalePolicy_GLRender, METH_VARARGS, "SoTextureScalePolicy_GLRender(SoTextureScalePolicy self, SoGLRenderAction action)"},
	 { "SoTextureScalePolicy_swigregister", SoTextureScalePolicy_swigregister, METH_O, NULL},
	 { "SoTextureScalePolicy_swiginit", SoTextureScalePolicy_swiginit, METH_VARARGS, NULL},
	 { "SoTextureUnit_getClassTypeId", _wrap_SoTextureUnit_getClassTypeId, METH_NOARGS, "SoTextureUnit_getClassTypeId() -> SoType"},
	 { "SoTextureUnit_getTypeId", _wrap_SoTextureUnit_getTypeId, METH_O, "SoTextureUnit_getTypeId(SoTextureUnit self) -> SoType"},
	 { "SoTextureUnit_initClass", _wrap_SoTextureUnit_initClass, METH_NOARGS, "SoTextureUnit_initClass()"},
	 { "new_SoTextureUnit", _wrap_new_SoTextureUnit, METH_NOARGS, "new_SoTextureUnit() -> SoTextureUnit"},
	 { "SoTextureUnit_unit_set", _wrap_SoTextureUnit_unit_set, METH_VARARGS, "SoTextureUnit_unit_set(SoTextureUnit self, SoSFInt32 unit)"},
	 { "SoTextureUnit_unit_get", _wrap_SoTextureUnit_unit_get, METH_O, "SoTextureUnit_unit_get(SoTextureUnit self) -> SoSFInt32"},
	 { "SoTextureUnit_mappingMethod_set", _wrap_SoTextureUnit_mappingMethod_set, METH_VARARGS, "SoTextureUnit_mappingMethod_set(SoTextureUnit self, SoSFEnum mappingMethod)"},
	 { "SoTextureUnit_mappingMethod_get", _wrap_SoTextureUnit_mappingMethod_get, METH_O, "SoTextureUnit_mappingMethod_get(SoTextureUnit self) -> SoSFEnum"},
	 { "SoTextureUnit_doAction", _wrap_SoTextureUnit_doAction, METH_VARARGS, "SoTextureUnit_doAction(SoTextureUnit self, SoAction action)"},
	 { "SoTextureUnit_callback", _wrap_SoTextureUnit_callback, METH_VARARGS, "SoTextureUnit_callback(SoTextureUnit self, SoCallbackAction action)"},
	 { "SoTextureUnit_GLRender", _wrap_SoTextureUnit_GLRender, METH_VARARGS, "SoTextureUnit_GLRender(SoTextureUnit self, SoGLRenderAction action)"},
	 { "SoTextureUnit_pick", _wrap_SoTextureUnit_pick, METH_VARARGS, "SoTextureUnit_pick(SoTextureUnit self, SoPickAction action)"},
	 { "SoTextureUnit_getBoundingBox", _wrap_SoTextureUnit_getBoundingBox, METH_VARARGS, "SoTextureUnit_getBoundingBox(SoTextureUnit self, SoGetBoundingBoxAction action)"},
	 { "SoTextureUnit_getMatrix", _wrap_SoTextureUnit_getMatrix, METH_VARARGS, "SoTextureUnit_getMatrix(SoTextureUnit self, SoGetMatrixAction action)"},
	 { "SoTextureUnit_getMaxTextureUnit", _wrap_SoTextureUnit_getMaxTextureUnit, METH_NOARGS, "SoTextureUnit_getMaxTextureUnit() -> uint32_t"},
	 { "SoTextureUnit_swigregister", SoTextureUnit_swigregister, METH_O, NULL},
	 { "SoTextureUnit_swiginit", SoTextureUnit_swiginit, METH_VARARGS, NULL},
	 { "SoTextureCombine_getClassTypeId", _wrap_SoTextureCombine_getClassTypeId, METH_NOARGS, "SoTextureCombine_getClassTypeId() -> SoType"},
	 { "SoTextureCombine_getTypeId", _wrap_SoTextureCombine_getTypeId, METH_O, "SoTextureCombine_getTypeId(SoTextureCombine self) -> SoType"},
	 { "SoTextureCombine_initClass", _wrap_SoTextureCombine_initClass, METH_NOARGS, "SoTextureCombine_initClass()"},
	 { "new_SoTextureCombine", _wrap_new_SoTextureCombine, METH_NOARGS, "new_SoTextureCombine() -> SoTextureCombine"},
	 { "SoTextureCombine_rgbSource_set", _wrap_SoTextureCombine_rgbSource_set, METH_VARARGS, "SoTextureCombine_rgbSource_set(SoTextureCombine self, SoMFEnum rgbSource)"},
	 { "SoTextureCombine_rgbSource_get", _wrap_SoTextureCombine_rgbSource_get, METH_O, "SoTextureCombine_rgbSource_get(SoTextureCombine self) -> SoMFEnum"},
	 { "SoTextureCombine_alphaSource_set", _wrap_SoTextureCombine_alphaSource_set, METH_VARARGS, "SoTextureCombine_alphaSource_set(SoTextureCombine self, SoMFEnum alphaSource)"},
	 { "SoTextureCombine_alphaSource_get", _wrap_SoTextureCombine_alphaSource_get, METH_O, "SoTextureCombine_alphaSource_get(SoTextureCombine self) -> SoMFEnum"},
	 { "SoTextureCombine_rgbOperand_set", _wrap_SoTextureCombine_rgbOperand_set, METH_VARARGS, "SoTextureCombine_rgbOperand_set(SoTextureCombine self, SoMFEnum rgbOperand)"},
	 { "SoTextureCombine_rgbOperand_get", _wrap_SoTextureCombine_rgbOperand_get, METH_O, "SoTextureCombine_rgbOperand_get(SoTextureCombine self) -> SoMFEnum"},
	 { "SoTextureCombine_alphaOperand_set", _wrap_SoTextureCombine_alphaOperand_set, METH_VARARGS, "SoTextureCombine_alphaOperand_set(SoTextureCombine self, SoMFEnum alphaOperand)"},
	 { "SoTextureCombine_alphaOperand_get", _wrap_SoTextureCombine_alphaOperand_get, METH_O, "SoTextureCombine_alphaOperand_get(SoTextureCombine self) -> SoMFEnum"},
	 { "SoTextureCombine_rgbOperation_set", _wrap_SoTextureCombine_rgbOperation_set, METH_VARARGS, "SoTextureCombine_rgbOperation_set(SoTextureCombine self, SoSFEnum rgbOperation)"},
	 { "SoTextureCombine_rgbOperation_get", _wrap_SoTextureCombine_rgbOperation_get, METH_O, "SoTextureCombine_rgbOperation_get(SoTextureCombine self) -> SoSFEnum"},
	 { "SoTextureCombine_alphaOperation_set", _wrap_SoTextureCombine_alphaOperation_set, METH_VARARGS, "SoTextureCombine_alphaOperation_set(SoTextureCombine self, SoSFEnum alphaOperation)"},
	 { "SoTextureCombine_alphaOperation_get", _wrap_SoTextureCombine_alphaOperation_get, METH_O, "SoTextureCombine_alphaOperation_get(SoTextureCombine self) -> SoSFEnum"},
	 { "SoTextureCombine_rgbScale_set", _wrap_SoTextureCombine_rgbScale_set, METH_VARARGS, "SoTextureCombine_rgbScale_set(SoTextureCombine self, SoSFFloat rgbScale)"},
	 { "SoTextureCombine_rgbScale_get", _wrap_SoTextureCombine_rgbScale_get, METH_O, "SoTextureCombine_rgbScale_get(SoTextureCombine self) -> SoSFFloat"},
	 { "SoTextureCombine_alphaScale_set", _wrap_SoTextureCombine_alphaScale_set, METH_VARARGS, "SoTextureCombine_alphaScale_set(SoTextureCombine self, SoSFFloat alphaScale)"},
	 { "SoTextureCombine_alphaScale_get", _wrap_SoTextureCombine_alphaScale_get, METH_O, "SoTextureCombine_alphaScale_get(SoTextureCombine self) -> SoSFFloat"},
	 { "SoTextureCombine_constantColor_set", _wrap_SoTextureCombine_constantColor_set, METH_VARARGS, "SoTextureCombine_constantColor_set(SoTextureCombine self, SoSFVec4f constantColor)"},
	 { "SoTextureCombine_constantColor_get", _wrap_SoTextureCombine_constantColor_get, METH_O, "SoTextureCombine_constantColor_get(SoTextureCombine self) -> SoSFVec4f"},
	 { "SoTextureCombine_doAction", _wrap_SoTextureCombine_doAction, METH_VARARGS, "SoTextureCombine_doAction(SoTextureCombine self, SoAction action)"},
	 { "SoTextureCombine_callback", _wrap_SoTextureCombine_callback, METH_VARARGS, "SoTextureCombine_callback(SoTextureCombine self, SoCallbackAction action)"},
	 { "SoTextureCombine_GLRender", _wrap_SoTextureCombine_GLRender, METH_VARARGS, "SoTextureCombine_GLRender(SoTextureCombine self, SoGLRenderAction action)"},
	 { "SoTextureCombine_pick", _wrap_SoTextureCombine_pick, METH_VARARGS, "SoTextureCombine_pick(SoTextureCombine self, SoPickAction action)"},
	 { "SoTextureCombine_swigregister", SoTextureCombine_swigregister, METH_O, NULL},
	 { "SoTextureCombine_swiginit", SoTextureCombine_swiginit, METH_VARARGS, NULL},
	 { "SoSceneTexture2_getClassTypeId", _wrap_SoSceneTexture2_getClassTypeId, METH_NOARGS, "SoSceneTexture2_getClassTypeId() -> SoType"},
	 { "SoSceneTexture2_getTypeId", _wrap_SoSceneTexture2_getTypeId, METH_O, "SoSceneTexture2_getTypeId(SoSceneTexture2 self) -> SoType"},
	 { "SoSceneTexture2_initClass", _wrap_SoSceneTexture2_initClass, METH_NOARGS, "SoSceneTexture2_initClass()"},
	 { "new_SoSceneTexture2", _wrap_new_SoSceneTexture2, METH_NOARGS, "new_SoSceneTexture2() -> SoSceneTexture2"},
	 { "SoSceneTexture2_wrapS_set", _wrap_SoSceneTexture2_wrapS_set, METH_VARARGS, "SoSceneTexture2_wrapS_set(SoSceneTexture2 self, SoSFEnum wrapS)"},
	 { "SoSceneTexture2_wrapS_get", _wrap_SoSceneTexture2_wrapS_get, METH_O, "SoSceneTexture2_wrapS_get(SoSceneTexture2 self) -> SoSFEnum"},
	 { "SoSceneTexture2_wrapT_set", _wrap_SoSceneTexture2_wrapT_set, METH_VARARGS, "SoSceneTexture2_wrapT_set(SoSceneTexture2 self, SoSFEnum wrapT)"},
	 { "SoSceneTexture2_wrapT_get", _wrap_SoSceneTexture2_wrapT_get, METH_O, "SoSceneTexture2_wrapT_get(SoSceneTexture2 self) -> SoSFEnum"},
	 { "SoSceneTexture2_model_set", _wrap_SoSceneTexture2_model_set, METH_VARARGS, "SoSceneTexture2_model_set(SoSceneTexture2 self, SoSFEnum model)"},
	 { "SoSceneTexture2_model_get", _wrap_SoSceneTexture2_model_get, METH_O, "SoSceneTexture2_model_get(SoSceneTexture2 self) -> SoSFEnum"},
	 { "SoSceneTexture2_blendColor_set", _wrap_SoSceneTexture2_blendColor_set, METH_VARARGS, "SoSceneTexture2_blendColor_set(SoSceneTexture2 self, SoSFColor blendColor)"},
	 { "SoSceneTexture2_blendColor_get", _wrap_SoSceneTexture2_blendColor_get, METH_O, "SoSceneTexture2_blendColor_get(SoSceneTexture2 self) -> SoSFColor"},
	 { "SoSceneTexture2_backgroundColor_set", _wrap_SoSceneTexture2_backgroundColor_set, METH_VARARGS, "SoSceneTexture2_backgroundColor_set(SoSceneTexture2 self, SoSFVec4f backgroundColor)"},
	 { "SoSceneTexture2_backgroundColor_get", _wrap_SoSceneTexture2_backgroundColor_get, METH_O, "SoSceneTexture2_backgroundColor_get(SoSceneTexture2 self) -> SoSFVec4f"},
	 { "SoSceneTexture2_size_set", _wrap_SoSceneTexture2_size_set, METH_VARARGS, "SoSceneTexture2_size_set(SoSceneTexture2 self, SoSFVec2s size)"},
	 { "SoSceneTexture2_size_get", _wrap_SoSceneTexture2_size_get, METH_O, "SoSceneTexture2_size_get(SoSceneTexture2 self) -> SoSFVec2s"},
	 { "SoSceneTexture2_scene_set", _wrap_SoSceneTexture2_scene_set, METH_VARARGS, "SoSceneTexture2_scene_set(SoSceneTexture2 self, SoSFNode scene)"},
	 { "SoSceneTexture2_scene_get", _wrap_SoSceneTexture2_scene_get, METH_O, "SoSceneTexture2_scene_get(SoSceneTexture2 self) -> SoSFNode"},
	 { "SoSceneTexture2_sceneTransparencyType_set", _wrap_SoSceneTexture2_sceneTransparencyType_set, METH_VARARGS, "SoSceneTexture2_sceneTransparencyType_set(SoSceneTexture2 self, SoSFNode sceneTransparencyType)"},
	 { "SoSceneTexture2_sceneTransparencyType_get", _wrap_SoSceneTexture2_sceneTransparencyType_get, METH_O, "SoSceneTexture2_sceneTransparencyType_get(SoSceneTexture2 self) -> SoSFNode"},
	 { "SoSceneTexture2_transparencyFunction_set", _wrap_SoSceneTexture2_transparencyFunction_set, METH_VARARGS, "SoSceneTexture2_transparencyFunction_set(SoSceneTexture2 self, SoSFEnum transparencyFunction)"},
	 { "SoSceneTexture2_transparencyFunction_get", _wrap_SoSceneTexture2_transparencyFunction_get, METH_O, "SoSceneTexture2_transparencyFunction_get(SoSceneTexture2 self) -> SoSFEnum"},
	 { "SoSceneTexture2_type_set", _wrap_SoSceneTexture2_type_set, METH_VARARGS, "SoSceneTexture2_type_set(SoSceneTexture2 self, SoSFEnum type)"},
	 { "SoSceneTexture2_type_get", _wrap_SoSceneTexture2_type_get, METH_O, "SoSceneTexture2_type_get(SoSceneTexture2 self) -> SoSFEnum"},
	 { "SoSceneTexture2_notify", _wrap_SoSceneTexture2_notify, METH_VARARGS, "SoSceneTexture2_notify(SoSceneTexture2 self, SoNotList list)"},
	 { "SoSceneTexture2_write", _wrap_SoSceneTexture2_write, METH_VARARGS, "SoSceneTexture2_write(SoSceneTexture2 self, SoWriteAction action)"},
	 { "SoSceneTexture2_doAction", _wrap_SoSceneTexture2_doAction, METH_VARARGS, "SoSceneTexture2_doAction(SoSceneTexture2 self, SoAction action)"},
	 { "SoSceneTexture2_GLRender", _wrap_SoSceneTexture2_GLRender, METH_VARARGS, "SoSceneTexture2_GLRender(SoSceneTexture2 self, SoGLRenderAction action)"},
	 { "SoSceneTexture2_callback", _wrap_SoSceneTexture2_callback, METH_VARARGS, "SoSceneTexture2_callback(SoSceneTexture2 self, SoCallbackAction action)"},
	 { "SoSceneTexture2_rayPick", _wrap_SoSceneTexture2_rayPick, METH_VARARGS, "SoSceneTexture2_rayPick(SoSceneTexture2 self, SoRayPickAction action)"},
	 { "SoSceneTexture2_swigregister", SoSceneTexture2_swigregister, METH_O, NULL},
	 { "SoSceneTexture2_swiginit", SoSceneTexture2_swiginit, METH_VARARGS, NULL},
	 { "SoSceneTextureCubeMap_getClassTypeId", _wrap_SoSceneTextureCubeMap_getClassTypeId, METH_NOARGS, "SoSceneTextureCubeMap_getClassTypeId() -> SoType"},
	 { "SoSceneTextureCubeMap_getTypeId", _wrap_SoSceneTextureCubeMap_getTypeId, METH_O, "SoSceneTextureCubeMap_getTypeId(SoSceneTextureCubeMap self) -> SoType"},
	 { "SoSceneTextureCubeMap_initClass", _wrap_SoSceneTextureCubeMap_initClass, METH_NOARGS, "SoSceneTextureCubeMap_initClass()"},
	 { "new_SoSceneTextureCubeMap", _wrap_new_SoSceneTextureCubeMap, METH_NOARGS, "new_SoSceneTextureCubeMap() -> SoSceneTextureCubeMap"},
	 { "SoSceneTextureCubeMap_size_set", _wrap_SoSceneTextureCubeMap_size_set, METH_VARARGS, "SoSceneTextureCubeMap_size_set(SoSceneTextureCubeMap self, SoSFVec2s size)"},
	 { "SoSceneTextureCubeMap_size_get", _wrap_SoSceneTextureCubeMap_size_get, METH_O, "SoSceneTextureCubeMap_size_get(SoSceneTextureCubeMap self) -> SoSFVec2s"},
	 { "SoSceneTextureCubeMap_scene_set", _wrap_SoSceneTextureCubeMap_scene_set, METH_VARARGS, "SoSceneTextureCubeMap_scene_set(SoSceneTextureCubeMap self, SoSFNode scene)"},
	 { "SoSceneTextureCubeMap_scene_get", _wrap_SoSceneTextureCubeMap_scene_get, METH_O, "SoSceneTextureCubeMap_scene_get(SoSceneTextureCubeMap self) -> SoSFNode"},
	 { "SoSceneTextureCubeMap_wrapS_set", _wrap_SoSceneTextureCubeMap_wrapS_set, METH_VARARGS, "SoSceneTextureCubeMap_wrapS_set(SoSceneTextureCubeMap self, SoSFEnum wrapS)"},
	 { "SoSceneTextureCubeMap_wrapS_get", _wrap_SoSceneTextureCubeMap_wrapS_get, METH_O, "SoSceneTextureCubeMap_wrapS_get(SoSceneTextureCubeMap self) -> SoSFEnum"},
	 { "SoSceneTextureCubeMap_wrapT_set", _wrap_SoSceneTextureCubeMap_wrapT_set, METH_VARARGS, "SoSceneTextureCubeMap_wrapT_set(SoSceneTextureCubeMap self, SoSFEnum wrapT)"},
	 { "SoSceneTextureCubeMap_wrapT_get", _wrap_SoSceneTextureCubeMap_wrapT_get, METH_O, "SoSceneTextureCubeMap_wrapT_get(SoSceneTextureCubeMap self) -> SoSFEnum"},
	 { "SoSceneTextureCubeMap_wrapR_set", _wrap_SoSceneTextureCubeMap_wrapR_set, METH_VARARGS, "SoSceneTextureCubeMap_wrapR_set(SoSceneTextureCubeMap self, SoSFEnum wrapR)"},
	 { "SoSceneTextureCubeMap_wrapR_get", _wrap_SoSceneTextureCubeMap_wrapR_get, METH_O, "SoSceneTextureCubeMap_wrapR_get(SoSceneTextureCubeMap self) -> SoSFEnum"},
	 { "SoSceneTextureCubeMap_model_set", _wrap_SoSceneTextureCubeMap_model_set, METH_VARARGS, "SoSceneTextureCubeMap_model_set(SoSceneTextureCubeMap self, SoSFEnum model)"},
	 { "SoSceneTextureCubeMap_model_get", _wrap_SoSceneTextureCubeMap_model_get, METH_O, "SoSceneTextureCubeMap_model_get(SoSceneTextureCubeMap self) -> SoSFEnum"},
	 { "SoSceneTextureCubeMap_backgroundColor_set", _wrap_SoSceneTextureCubeMap_backgroundColor_set, METH_VARARGS, "SoSceneTextureCubeMap_backgroundColor_set(SoSceneTextureCubeMap self, SoSFColor backgroundColor)"},
	 { "SoSceneTextureCubeMap_backgroundColor_get", _wrap_SoSceneTextureCubeMap_backgroundColor_get, METH_O, "SoSceneTextureCubeMap_backgroundColor_get(SoSceneTextureCubeMap self) -> SoSFColor"},
	 { "SoSceneTextureCubeMap_transparencyFunction_set", _wrap_SoSceneTextureCubeMap_transparencyFunction_set, METH_VARARGS, "SoSceneTextureCubeMap_transparencyFunction_set(SoSceneTextureCubeMap self, SoSFEnum transparencyFunction)"},
	 { "SoSceneTextureCubeMap_transparencyFunction_get", _wrap_SoSceneTextureCubeMap_transparencyFunction_get, METH_O, "SoSceneTextureCubeMap_transparencyFunction_get(SoSceneTextureCubeMap self) -> SoSFEnum"},
	 { "SoSceneTextureCubeMap_blendColor_set", _wrap_SoSceneTextureCubeMap_blendColor_set, METH_VARARGS, "SoSceneTextureCubeMap_blendColor_set(SoSceneTextureCubeMap self, SoSFColor blendColor)"},
	 { "SoSceneTextureCubeMap_blendColor_get", _wrap_SoSceneTextureCubeMap_blendColor_get, METH_O, "SoSceneTextureCubeMap_blendColor_get(SoSceneTextureCubeMap self) -> SoSFColor"},
	 { "SoSceneTextureCubeMap_doAction", _wrap_SoSceneTextureCubeMap_doAction, METH_VARARGS, "SoSceneTextureCubeMap_doAction(SoSceneTextureCubeMap self, SoAction action)"},
	 { "SoSceneTextureCubeMap_GLRender", _wrap_SoSceneTextureCubeMap_GLRender, METH_VARARGS, "SoSceneTextureCubeMap_GLRender(SoSceneTextureCubeMap self, SoGLRenderAction action)"},
	 { "SoSceneTextureCubeMap_callback", _wrap_SoSceneTextureCubeMap_callback, METH_VARARGS, "SoSceneTextureCubeMap_callback(SoSceneTextureCubeMap self, SoCallbackAction action)"},
	 { "SoSceneTextureCubeMap_rayPick", _wrap_SoSceneTextureCubeMap_rayPick, METH_VARARGS, "SoSceneTextureCubeMap_rayPick(SoSceneTextureCubeMap self, SoRayPickAction action)"},
	 { "SoSceneTextureCubeMap_swigregister", SoSceneTextureCubeMap_swigregister, METH_O, NULL},
	 { "SoSceneTextureCubeMap_swiginit", SoSceneTextureCubeMap_swiginit, METH_VARARGS, NULL},
	 { "SoCacheHintElement_getClassTypeId", _wrap_SoCacheHintElement_getClassTypeId, METH_NOARGS, "SoCacheHintElement_getClassTypeId() -> SoType"},
	 { "SoCacheHintElement_getClassStackIndex", _wrap_SoCacheHintElement_getClassStackIndex, METH_NOARGS, "SoCacheHintElement_getClassStackIndex() -> int"},
	 { "SoCacheHintElement_createInstance", _wrap_SoCacheHintElement_createInstance, METH_NOARGS, "SoCacheHintElement_createInstance() -> void *"},
	 { "SoCacheHintElement_initClass", _wrap_SoCacheHintElement_initClass, METH_NOARGS, "SoCacheHintElement_initClass()"},
	 { "SoCacheHintElement_init", _wrap_SoCacheHintElement_init, METH_VARARGS, "SoCacheHintElement_init(SoCacheHintElement self, SoState state)"},
	 { "SoCacheHintElement_push", _wrap_SoCacheHintElement_push, METH_VARARGS, "SoCacheHintElement_push(SoCacheHintElement self, SoState state)"},
	 { "SoCacheHintElement_pop", _wrap_SoCacheHintElement_pop, METH_VARARGS, "SoCacheHintElement_pop(SoCacheHintElement self, SoState state, SoElement prevtopelement)"},
	 { "SoCacheHintElement_matches", _wrap_SoCacheHintElement_matches, METH_VARARGS, "SoCacheHintElement_matches(SoCacheHintElement self, SoElement element) -> SbBool"},
	 { "SoCacheHintElement_copyMatchInfo", _wrap_SoCacheHintElement_copyMatchInfo, METH_O, "SoCacheHintElement_copyMatchInfo(SoCacheHintElement self) -> SoElement"},
	 { "SoCacheHintElement_set", _wrap_SoCacheHintElement_set, METH_VARARGS, "SoCacheHintElement_set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"},
	 { "SoCacheHintElement_get", _wrap_SoCacheHintElement_get, METH_VARARGS, "SoCacheHintElement_get(SoState state, float & memvalue, float & gfxvalue)"},
	 { "SoCacheHintElement_swigregister", SoCacheHintElement_swigregister, METH_O, NULL},
	 { "SoCacheHint_getClassTypeId", _wrap_SoCacheHint_getClassTypeId, METH_NOARGS, "SoCacheHint_getClassTypeId() -> SoType"},
	 { "SoCacheHint_getTypeId", _wrap_SoCacheHint_getTypeId, METH_O, "SoCacheHint_getTypeId(SoCacheHint self) -> SoType"},
	 { "SoCacheHint_initClass", _wrap_SoCacheHint_initClass, METH_NOARGS, "SoCacheHint_initClass()"},
	 { "new_SoCacheHint", _wrap_new_SoCacheHint, METH_NOARGS, "new_SoCacheHint() -> SoCacheHint"},
	 { "SoCacheHint_memValue_set", _wrap_SoCacheHint_memValue_set, METH_VARARGS, "SoCacheHint_memValue_set(SoCacheHint self, SoSFFloat memValue)"},
	 { "SoCacheHint_memValue_get", _wrap_SoCacheHint_memValue_get, METH_O, "SoCacheHint_memValue_get(SoCacheHint self) -> SoSFFloat"},
	 { "SoCacheHint_gfxValue_set", _wrap_SoCacheHint_gfxValue_set, METH_VARARGS, "SoCacheHint_gfxValue_set(SoCacheHint self, SoSFFloat gfxValue)"},
	 { "SoCacheHint_gfxValue_get", _wrap_SoCacheHint_gfxValue_get, METH_O, "SoCacheHint_gfxValue_get(SoCacheHint self) -> SoSFFloat"},
	 { "SoCacheHint_doAction", _wrap_SoCacheHint_doAction, METH_VARARGS, "SoCacheHint_doAction(SoCacheHint self, SoAction action)"},
	 { "SoCacheHint_GLRender", _wrap_SoCacheHint_GLRender, METH_VARARGS, "SoCacheHint_GLRender(SoCacheHint self, SoGLRenderAction action)"},
	 { "SoCacheHint_callback", _wrap_SoCacheHint_callback, METH_VARARGS, "SoCacheHint_callback(SoCacheHint self, SoCallbackAction action)"},
	 { "SoCacheHint_getBoundingBox", _wrap_SoCacheHint_getBoundingBox, METH_VARARGS, "SoCacheHint_getBoundingBox(SoCacheHint self, SoGetBoundingBoxAction action)"},
	 { "SoCacheHint_pick", _wrap_SoCacheHint_pick, METH_VARARGS, "SoCacheHint_pick(SoCacheHint self, SoPickAction action)"},
	 { "SoCacheHint_swigregister", SoCacheHint_swigregister, METH_O, NULL},
	 { "SoCacheHint_swiginit", SoCacheHint_swiginit, METH_VARARGS, NULL},
	 { "SoDepthBuffer_getClassTypeId", _wrap_SoDepthBuffer_getClassTypeId, METH_NOARGS, "SoDepthBuffer_getClassTypeId() -> SoType"},
	 { "SoDepthBuffer_getTypeId", _wrap_SoDepthBuffer_getTypeId, METH_O, "SoDepthBuffer_getTypeId(SoDepthBuffer self) -> SoType"},
	 { "SoDepthBuffer_initClass", _wrap_SoDepthBuffer_initClass, METH_NOARGS, "SoDepthBuffer_initClass()"},
	 { "new_SoDepthBuffer", _wrap_new_SoDepthBuffer, METH_NOARGS, "new_SoDepthBuffer() -> SoDepthBuffer"},
	 { "SoDepthBuffer_test_set", _wrap_SoDepthBuffer_test_set, METH_VARARGS, "SoDepthBuffer_test_set(SoDepthBuffer self, SoSFBool test)"},
	 { "SoDepthBuffer_test_get", _wrap_SoDepthBuffer_test_get, METH_O, "SoDepthBuffer_test_get(SoDepthBuffer self) -> SoSFBool"},
	 { "SoDepthBuffer_write_set", _wrap_SoDepthBuffer_write_set, METH_VARARGS, "SoDepthBuffer_write_set(SoDepthBuffer self, SoSFBool write)"},
	 { "SoDepthBuffer_write_get", _wrap_SoDepthBuffer_write_get, METH_O, "SoDepthBuffer_write_get(SoDepthBuffer self) -> SoSFBool"},
	 { "SoDepthBuffer_function_set", _wrap_SoDepthBuffer_function_set, METH_VARARGS, "SoDepthBuffer_function_set(SoDepthBuffer self, SoSFEnum function)"},
	 { "SoDepthBuffer_function_get", _wrap_SoDepthBuffer_function_get, METH_O, "SoDepthBuffer_function_get(SoDepthBuffer self) -> SoSFEnum"},
	 { "SoDepthBuffer_range_set", _wrap_SoDepthBuffer_range_set, METH_VARARGS, "SoDepthBuffer_range_set(SoDepthBuffer self, SoSFVec2f range)"},
	 { "SoDepthBuffer_range_get", _wrap_SoDepthBuffer_range_get, METH_O, "SoDepthBuffer_range_get(SoDepthBuffer self) -> SoSFVec2f"},
	 { "SoDepthBuffer_GLRender", _wrap_SoDepthBuffer_GLRender, METH_VARARGS, "SoDepthBuffer_GLRender(SoDepthBuffer self, SoGLRenderAction action)"},
	 { "SoDepthBuffer_swigregister", SoDepthBuffer_swigregister, METH_O, NULL},
	 { "SoDepthBuffer_swiginit", SoDepthBuffer_swiginit, METH_VARARGS, NULL},
	 { "SoAlphaTest_getClassTypeId", _wrap_SoAlphaTest_getClassTypeId, METH_NOARGS, "SoAlphaTest_getClassTypeId() -> SoType"},
	 { "SoAlphaTest_getTypeId", _wrap_SoAlphaTest_getTypeId, METH_O, "SoAlphaTest_getTypeId(SoAlphaTest self) -> SoType"},
	 { "SoAlphaTest_initClass", _wrap_SoAlphaTest_initClass, METH_NOARGS, "SoAlphaTest_initClass()"},
	 { "new_SoAlphaTest", _wrap_new_SoAlphaTest, METH_NOARGS, "new_SoAlphaTest() -> SoAlphaTest"},
	 { "SoAlphaTest_function_set", _wrap_SoAlphaTest_function_set, METH_VARARGS, "SoAlphaTest_function_set(SoAlphaTest self, SoSFEnum function)"},
	 { "SoAlphaTest_function_get", _wrap_SoAlphaTest_function_get, METH_O, "SoAlphaTest_function_get(SoAlphaTest self) -> SoSFEnum"},
	 { "SoAlphaTest_value_set", _wrap_SoAlphaTest_value_set, METH_VARARGS, "SoAlphaTest_value_set(SoAlphaTest self, SoSFFloat value)"},
	 { "SoAlphaTest_value_get", _wrap_SoAlphaTest_value_get, METH_O, "SoAlphaTest_value_get(SoAlphaTest self) -> SoSFFloat"},
	 { "SoAlphaTest_GLRender", _wrap_SoAlphaTest_GLRender, METH_VARARGS, "SoAlphaTest_GLRender(SoAlphaTest self, SoGLRenderAction action)"},
	 { "SoAlphaTest_swigregister", SoAlphaTest_swigregister, METH_O, NULL},
	 { "SoAlphaTest_swiginit", SoAlphaTest_swiginit, METH_VARARGS, NULL},
	 { "new_SbLine", _wrap_new_SbLine, METH_VARARGS, "\n"
		"SbLine()\n"
		"new_SbLine(SbVec3f origin, SbVec3f point) -> SbLine\n"
		""},
	 { "SbLine_setValue", _wrap_SbLine_setValue, METH_VARARGS, "SbLine_setValue(SbLine self, SbVec3f origin, SbVec3f point)"},
	 { "SbLine_setPosDir", _wrap_SbLine_setPosDir, METH_VARARGS, "SbLine_setPosDir(SbLine self, SbVec3f position, SbVec3f direction)"},
	 { "SbLine_getClosestPoints", _wrap_SbLine_getClosestPoints, METH_VARARGS, "SbLine_getClosestPoints(SbLine self, SbLine line2, SbVec3f ptOnThis, SbVec3f ptOnLine2) -> SbBool"},
	 { "SbLine_getClosestPoint", _wrap_SbLine_getClosestPoint, METH_VARARGS, "SbLine_getClosestPoint(SbLine self, SbVec3f point) -> SbVec3f"},
	 { "SbLine_getPosition", _wrap_SbLine_getPosition, METH_O, "SbLine_getPosition(SbLine self) -> SbVec3f"},
	 { "SbLine_getDirection", _wrap_SbLine_getDirection, METH_O, "SbLine_getDirection(SbLine self) -> SbVec3f"},
	 { "SbLine_output", _wrap_SbLine_output, METH_VARARGS, "SbLine_output(SbLine self, FILE * file)"},
	 { "delete_SbLine", _wrap_delete_SbLine, METH_O, "delete_SbLine(SbLine self)"},
	 { "SbLine_swigregister", SbLine_swigregister, METH_O, NULL},
	 { "SbLine_swiginit", SbLine_swiginit, METH_VARARGS, NULL},
	 { "SbProjector_project", _wrap_SbProjector_project, METH_VARARGS, "SbProjector_project(SbProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbProjector_setViewVolume", _wrap_SbProjector_setViewVolume, METH_VARARGS, "SbProjector_setViewVolume(SbProjector self, SbViewVolume vol)"},
	 { "SbProjector_getViewVolume", _wrap_SbProjector_getViewVolume, METH_O, "SbProjector_getViewVolume(SbProjector self) -> SbViewVolume"},
	 { "SbProjector_setWorkingSpace", _wrap_SbProjector_setWorkingSpace, METH_VARARGS, "SbProjector_setWorkingSpace(SbProjector self, SbMatrix space)"},
	 { "SbProjector_getWorkingSpace", _wrap_SbProjector_getWorkingSpace, METH_O, "SbProjector_getWorkingSpace(SbProjector self) -> SbMatrix"},
	 { "SbProjector_copy", _wrap_SbProjector_copy, METH_O, "SbProjector_copy(SbProjector self) -> SbProjector"},
	 { "SbProjector_tryProject", _wrap_SbProjector_tryProject, METH_VARARGS, "SbProjector_tryProject(SbProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"},
	 { "SbProjector_swigregister", SbProjector_swigregister, METH_O, NULL},
	 { "new_SbCylinder", _wrap_new_SbCylinder, METH_VARARGS, "\n"
		"SbCylinder()\n"
		"new_SbCylinder(SbLine a, float const r) -> SbCylinder\n"
		""},
	 { "SbCylinder_setValue", _wrap_SbCylinder_setValue, METH_VARARGS, "SbCylinder_setValue(SbCylinder self, SbLine a, float const r)"},
	 { "SbCylinder_setAxis", _wrap_SbCylinder_setAxis, METH_VARARGS, "SbCylinder_setAxis(SbCylinder self, SbLine a)"},
	 { "SbCylinder_setRadius", _wrap_SbCylinder_setRadius, METH_VARARGS, "SbCylinder_setRadius(SbCylinder self, float const r)"},
	 { "SbCylinder_getAxis", _wrap_SbCylinder_getAxis, METH_O, "SbCylinder_getAxis(SbCylinder self) -> SbLine"},
	 { "SbCylinder_getRadius", _wrap_SbCylinder_getRadius, METH_O, "SbCylinder_getRadius(SbCylinder self) -> float"},
	 { "SbCylinder_intersect", _wrap_SbCylinder_intersect, METH_VARARGS, "\n"
		"SbCylinder_intersect(SbCylinder self, SbLine l, SbVec3f intersection) -> SbBool\n"
		"SbCylinder_intersect(SbCylinder self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool\n"
		""},
	 { "SbCylinder_output", _wrap_SbCylinder_output, METH_VARARGS, "SbCylinder_output(SbCylinder self, FILE * file)"},
	 { "delete_SbCylinder", _wrap_delete_SbCylinder, METH_O, "delete_SbCylinder(SbCylinder self)"},
	 { "SbCylinder_swigregister", SbCylinder_swigregister, METH_O, NULL},
	 { "SbCylinder_swiginit", SbCylinder_swiginit, METH_VARARGS, NULL},
	 { "SbCylinderProjector_project", _wrap_SbCylinderProjector_project, METH_VARARGS, "SbCylinderProjector_project(SbCylinderProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbCylinderProjector_projectAndGetRotation", _wrap_SbCylinderProjector_projectAndGetRotation, METH_VARARGS, "SbCylinderProjector_projectAndGetRotation(SbCylinderProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"},
	 { "SbCylinderProjector_getRotation", _wrap_SbCylinderProjector_getRotation, METH_VARARGS, "SbCylinderProjector_getRotation(SbCylinderProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "SbCylinderProjector_setCylinder", _wrap_SbCylinderProjector_setCylinder, METH_VARARGS, "SbCylinderProjector_setCylinder(SbCylinderProjector self, SbCylinder cyl)"},
	 { "SbCylinderProjector_getCylinder", _wrap_SbCylinderProjector_getCylinder, METH_O, "SbCylinderProjector_getCylinder(SbCylinderProjector self) -> SbCylinder"},
	 { "SbCylinderProjector_setOrientToEye", _wrap_SbCylinderProjector_setOrientToEye, METH_VARARGS, "SbCylinderProjector_setOrientToEye(SbCylinderProjector self, SbBool const orienttoeye)"},
	 { "SbCylinderProjector_isOrientToEye", _wrap_SbCylinderProjector_isOrientToEye, METH_O, "SbCylinderProjector_isOrientToEye(SbCylinderProjector self) -> SbBool"},
	 { "SbCylinderProjector_setFront", _wrap_SbCylinderProjector_setFront, METH_VARARGS, "SbCylinderProjector_setFront(SbCylinderProjector self, SbBool const infront)"},
	 { "SbCylinderProjector_isFront", _wrap_SbCylinderProjector_isFront, METH_O, "SbCylinderProjector_isFront(SbCylinderProjector self) -> SbBool"},
	 { "SbCylinderProjector_isPointInFront", _wrap_SbCylinderProjector_isPointInFront, METH_VARARGS, "SbCylinderProjector_isPointInFront(SbCylinderProjector self, SbVec3f point) -> SbBool"},
	 { "SbCylinderProjector_setWorkingSpace", _wrap_SbCylinderProjector_setWorkingSpace, METH_VARARGS, "SbCylinderProjector_setWorkingSpace(SbCylinderProjector self, SbMatrix space)"},
	 { "delete_SbCylinderProjector", _wrap_delete_SbCylinderProjector, METH_O, "delete_SbCylinderProjector(SbCylinderProjector self)"},
	 { "SbCylinderProjector_swigregister", SbCylinderProjector_swigregister, METH_O, NULL},
	 { "new_SbCylinderSectionProjector", _wrap_new_SbCylinderSectionProjector, METH_VARARGS, "\n"
		"SbCylinderSectionProjector(float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		"SbCylinderSectionProjector(SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		""},
	 { "SbCylinderSectionProjector_copy", _wrap_SbCylinderSectionProjector_copy, METH_O, "SbCylinderSectionProjector_copy(SbCylinderSectionProjector self) -> SbProjector"},
	 { "SbCylinderSectionProjector_project", _wrap_SbCylinderSectionProjector_project, METH_VARARGS, "SbCylinderSectionProjector_project(SbCylinderSectionProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbCylinderSectionProjector_getRotation", _wrap_SbCylinderSectionProjector_getRotation, METH_VARARGS, "SbCylinderSectionProjector_getRotation(SbCylinderSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "SbCylinderSectionProjector_setTolerance", _wrap_SbCylinderSectionProjector_setTolerance, METH_VARARGS, "SbCylinderSectionProjector_setTolerance(SbCylinderSectionProjector self, float const edgetol)"},
	 { "SbCylinderSectionProjector_getTolerance", _wrap_SbCylinderSectionProjector_getTolerance, METH_O, "SbCylinderSectionProjector_getTolerance(SbCylinderSectionProjector self) -> float"},
	 { "SbCylinderSectionProjector_isWithinTolerance", _wrap_SbCylinderSectionProjector_isWithinTolerance, METH_VARARGS, "SbCylinderSectionProjector_isWithinTolerance(SbCylinderSectionProjector self, SbVec3f point) -> SbBool"},
	 { "delete_SbCylinderSectionProjector", _wrap_delete_SbCylinderSectionProjector, METH_O, "delete_SbCylinderSectionProjector(SbCylinderSectionProjector self)"},
	 { "SbCylinderSectionProjector_swigregister", SbCylinderSectionProjector_swigregister, METH_O, NULL},
	 { "SbCylinderSectionProjector_swiginit", SbCylinderSectionProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbCylinderPlaneProjector", _wrap_new_SbCylinderPlaneProjector, METH_VARARGS, "\n"
		"SbCylinderPlaneProjector(float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		"SbCylinderPlaneProjector(SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		""},
	 { "SbCylinderPlaneProjector_copy", _wrap_SbCylinderPlaneProjector_copy, METH_O, "SbCylinderPlaneProjector_copy(SbCylinderPlaneProjector self) -> SbProjector"},
	 { "SbCylinderPlaneProjector_project", _wrap_SbCylinderPlaneProjector_project, METH_VARARGS, "SbCylinderPlaneProjector_project(SbCylinderPlaneProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbCylinderPlaneProjector_getRotation", _wrap_SbCylinderPlaneProjector_getRotation, METH_VARARGS, "SbCylinderPlaneProjector_getRotation(SbCylinderPlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "delete_SbCylinderPlaneProjector", _wrap_delete_SbCylinderPlaneProjector, METH_O, "delete_SbCylinderPlaneProjector(SbCylinderPlaneProjector self)"},
	 { "SbCylinderPlaneProjector_swigregister", SbCylinderPlaneProjector_swigregister, METH_O, NULL},
	 { "SbCylinderPlaneProjector_swiginit", SbCylinderPlaneProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbCylinderSheetProjector", _wrap_new_SbCylinderSheetProjector, METH_VARARGS, "\n"
		"SbCylinderSheetProjector(SbBool const orienttoeye=1)\n"
		"SbCylinderSheetProjector(SbCylinder cyl, SbBool const orienttoeye=1)\n"
		""},
	 { "SbCylinderSheetProjector_copy", _wrap_SbCylinderSheetProjector_copy, METH_O, "SbCylinderSheetProjector_copy(SbCylinderSheetProjector self) -> SbProjector"},
	 { "SbCylinderSheetProjector_project", _wrap_SbCylinderSheetProjector_project, METH_VARARGS, "SbCylinderSheetProjector_project(SbCylinderSheetProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbCylinderSheetProjector_getRotation", _wrap_SbCylinderSheetProjector_getRotation, METH_VARARGS, "SbCylinderSheetProjector_getRotation(SbCylinderSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "delete_SbCylinderSheetProjector", _wrap_delete_SbCylinderSheetProjector, METH_O, "delete_SbCylinderSheetProjector(SbCylinderSheetProjector self)"},
	 { "SbCylinderSheetProjector_swigregister", SbCylinderSheetProjector_swigregister, METH_O, NULL},
	 { "SbCylinderSheetProjector_swiginit", SbCylinderSheetProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbLineProjector", _wrap_new_SbLineProjector, METH_NOARGS, "new_SbLineProjector() -> SbLineProjector"},
	 { "SbLineProjector_copy", _wrap_SbLineProjector_copy, METH_O, "SbLineProjector_copy(SbLineProjector self) -> SbProjector"},
	 { "SbLineProjector_project", _wrap_SbLineProjector_project, METH_VARARGS, "SbLineProjector_project(SbLineProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbLineProjector_tryProject", _wrap_SbLineProjector_tryProject, METH_VARARGS, "SbLineProjector_tryProject(SbLineProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"},
	 { "SbLineProjector_setLine", _wrap_SbLineProjector_setLine, METH_VARARGS, "SbLineProjector_setLine(SbLineProjector self, SbLine line)"},
	 { "SbLineProjector_getLine", _wrap_SbLineProjector_getLine, METH_O, "SbLineProjector_getLine(SbLineProjector self) -> SbLine"},
	 { "SbLineProjector_getVector", _wrap_SbLineProjector_getVector, METH_VARARGS, "\n"
		"SbLineProjector_getVector(SbLineProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f\n"
		"SbLineProjector_getVector(SbLineProjector self, SbVec2f viewpos) -> SbVec3f\n"
		""},
	 { "SbLineProjector_setStartPosition", _wrap_SbLineProjector_setStartPosition, METH_VARARGS, "\n"
		"SbLineProjector_setStartPosition(SbLineProjector self, SbVec2f viewpos)\n"
		"SbLineProjector_setStartPosition(SbLineProjector self, SbVec3f point)\n"
		""},
	 { "delete_SbLineProjector", _wrap_delete_SbLineProjector, METH_O, "delete_SbLineProjector(SbLineProjector self)"},
	 { "SbLineProjector_swigregister", SbLineProjector_swigregister, METH_O, NULL},
	 { "SbLineProjector_swiginit", SbLineProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbPlaneProjector", _wrap_new_SbPlaneProjector, METH_VARARGS, "\n"
		"SbPlaneProjector(SbBool const orient=0)\n"
		"SbPlaneProjector(SbPlane plane, SbBool const orient=0)\n"
		""},
	 { "SbPlaneProjector_copy", _wrap_SbPlaneProjector_copy, METH_O, "SbPlaneProjector_copy(SbPlaneProjector self) -> SbProjector"},
	 { "SbPlaneProjector_project", _wrap_SbPlaneProjector_project, METH_VARARGS, "SbPlaneProjector_project(SbPlaneProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbPlaneProjector_tryProject", _wrap_SbPlaneProjector_tryProject, METH_VARARGS, "SbPlaneProjector_tryProject(SbPlaneProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"},
	 { "SbPlaneProjector_setPlane", _wrap_SbPlaneProjector_setPlane, METH_VARARGS, "SbPlaneProjector_setPlane(SbPlaneProjector self, SbPlane plane)"},
	 { "SbPlaneProjector_getPlane", _wrap_SbPlaneProjector_getPlane, METH_O, "SbPlaneProjector_getPlane(SbPlaneProjector self) -> SbPlane"},
	 { "SbPlaneProjector_setOrientToEye", _wrap_SbPlaneProjector_setOrientToEye, METH_VARARGS, "SbPlaneProjector_setOrientToEye(SbPlaneProjector self, SbBool const orienttoeye)"},
	 { "SbPlaneProjector_isOrientToEye", _wrap_SbPlaneProjector_isOrientToEye, METH_O, "SbPlaneProjector_isOrientToEye(SbPlaneProjector self) -> SbBool"},
	 { "SbPlaneProjector_getVector", _wrap_SbPlaneProjector_getVector, METH_VARARGS, "\n"
		"SbPlaneProjector_getVector(SbPlaneProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f\n"
		"SbPlaneProjector_getVector(SbPlaneProjector self, SbVec2f viewpos) -> SbVec3f\n"
		""},
	 { "SbPlaneProjector_setStartPosition", _wrap_SbPlaneProjector_setStartPosition, METH_VARARGS, "\n"
		"SbPlaneProjector_setStartPosition(SbPlaneProjector self, SbVec2f viewpos)\n"
		"SbPlaneProjector_setStartPosition(SbPlaneProjector self, SbVec3f point)\n"
		""},
	 { "delete_SbPlaneProjector", _wrap_delete_SbPlaneProjector, METH_O, "delete_SbPlaneProjector(SbPlaneProjector self)"},
	 { "SbPlaneProjector_swigregister", SbPlaneProjector_swigregister, METH_O, NULL},
	 { "SbPlaneProjector_swiginit", SbPlaneProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbSphere", _wrap_new_SbSphere, METH_VARARGS, "\n"
		"SbSphere()\n"
		"new_SbSphere(SbVec3f center, float const radius) -> SbSphere\n"
		""},
	 { "SbSphere_setValue", _wrap_SbSphere_setValue, METH_VARARGS, "SbSphere_setValue(SbSphere self, SbVec3f center, float const radius)"},
	 { "SbSphere_setCenter", _wrap_SbSphere_setCenter, METH_VARARGS, "SbSphere_setCenter(SbSphere self, SbVec3f center)"},
	 { "SbSphere_setRadius", _wrap_SbSphere_setRadius, METH_VARARGS, "SbSphere_setRadius(SbSphere self, float const radius)"},
	 { "SbSphere_getCenter", _wrap_SbSphere_getCenter, METH_O, "SbSphere_getCenter(SbSphere self) -> SbVec3f"},
	 { "SbSphere_getRadius", _wrap_SbSphere_getRadius, METH_O, "SbSphere_getRadius(SbSphere self) -> float"},
	 { "SbSphere_circumscribe", _wrap_SbSphere_circumscribe, METH_VARARGS, "SbSphere_circumscribe(SbSphere self, SbBox3f box)"},
	 { "SbSphere_intersect", _wrap_SbSphere_intersect, METH_VARARGS, "\n"
		"SbSphere_intersect(SbSphere self, SbLine l, SbVec3f intersection) -> SbBool\n"
		"SbSphere_intersect(SbSphere self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool\n"
		""},
	 { "SbSphere_pointInside", _wrap_SbSphere_pointInside, METH_VARARGS, "SbSphere_pointInside(SbSphere self, SbVec3f p) -> SbBool"},
	 { "SbSphere_output", _wrap_SbSphere_output, METH_VARARGS, "SbSphere_output(SbSphere self, FILE * file)"},
	 { "delete_SbSphere", _wrap_delete_SbSphere, METH_O, "delete_SbSphere(SbSphere self)"},
	 { "SbSphere_swigregister", SbSphere_swigregister, METH_O, NULL},
	 { "SbSphere_swiginit", SbSphere_swiginit, METH_VARARGS, NULL},
	 { "SbSphereProjector_projectAndGetRotation", _wrap_SbSphereProjector_projectAndGetRotation, METH_VARARGS, "SbSphereProjector_projectAndGetRotation(SbSphereProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"},
	 { "SbSphereProjector_getRotation", _wrap_SbSphereProjector_getRotation, METH_VARARGS, "SbSphereProjector_getRotation(SbSphereProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "SbSphereProjector_setSphere", _wrap_SbSphereProjector_setSphere, METH_VARARGS, "SbSphereProjector_setSphere(SbSphereProjector self, SbSphere sph)"},
	 { "SbSphereProjector_getSphere", _wrap_SbSphereProjector_getSphere, METH_O, "SbSphereProjector_getSphere(SbSphereProjector self) -> SbSphere"},
	 { "SbSphereProjector_setOrientToEye", _wrap_SbSphereProjector_setOrientToEye, METH_VARARGS, "SbSphereProjector_setOrientToEye(SbSphereProjector self, SbBool const orienttoeye)"},
	 { "SbSphereProjector_isOrientToEye", _wrap_SbSphereProjector_isOrientToEye, METH_O, "SbSphereProjector_isOrientToEye(SbSphereProjector self) -> SbBool"},
	 { "SbSphereProjector_setFront", _wrap_SbSphereProjector_setFront, METH_VARARGS, "SbSphereProjector_setFront(SbSphereProjector self, SbBool const infront)"},
	 { "SbSphereProjector_isFront", _wrap_SbSphereProjector_isFront, METH_O, "SbSphereProjector_isFront(SbSphereProjector self) -> SbBool"},
	 { "SbSphereProjector_isPointInFront", _wrap_SbSphereProjector_isPointInFront, METH_VARARGS, "SbSphereProjector_isPointInFront(SbSphereProjector self, SbVec3f point) -> SbBool"},
	 { "SbSphereProjector_setWorkingSpace", _wrap_SbSphereProjector_setWorkingSpace, METH_VARARGS, "SbSphereProjector_setWorkingSpace(SbSphereProjector self, SbMatrix space)"},
	 { "delete_SbSphereProjector", _wrap_delete_SbSphereProjector, METH_O, "delete_SbSphereProjector(SbSphereProjector self)"},
	 { "SbSphereProjector_swigregister", SbSphereProjector_swigregister, METH_O, NULL},
	 { "new_SbSphereSheetProjector", _wrap_new_SbSphereSheetProjector, METH_VARARGS, "\n"
		"SbSphereSheetProjector(SbBool const orienttoeye=1)\n"
		"SbSphereSheetProjector(SbSphere sph, SbBool const orienttoeye=1)\n"
		""},
	 { "SbSphereSheetProjector_copy", _wrap_SbSphereSheetProjector_copy, METH_O, "SbSphereSheetProjector_copy(SbSphereSheetProjector self) -> SbProjector"},
	 { "SbSphereSheetProjector_project", _wrap_SbSphereSheetProjector_project, METH_VARARGS, "SbSphereSheetProjector_project(SbSphereSheetProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbSphereSheetProjector_getRotation", _wrap_SbSphereSheetProjector_getRotation, METH_VARARGS, "SbSphereSheetProjector_getRotation(SbSphereSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "delete_SbSphereSheetProjector", _wrap_delete_SbSphereSheetProjector, METH_O, "delete_SbSphereSheetProjector(SbSphereSheetProjector self)"},
	 { "SbSphereSheetProjector_swigregister", SbSphereSheetProjector_swigregister, METH_O, NULL},
	 { "SbSphereSheetProjector_swiginit", SbSphereSheetProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbSphereSectionProjector", _wrap_new_SbSphereSectionProjector, METH_VARARGS, "\n"
		"SbSphereSectionProjector(float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		"SbSphereSectionProjector(SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		""},
	 { "SbSphereSectionProjector_copy", _wrap_SbSphereSectionProjector_copy, METH_O, "SbSphereSectionProjector_copy(SbSphereSectionProjector self) -> SbProjector"},
	 { "SbSphereSectionProjector_project", _wrap_SbSphereSectionProjector_project, METH_VARARGS, "SbSphereSectionProjector_project(SbSphereSectionProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbSphereSectionProjector_getRotation", _wrap_SbSphereSectionProjector_getRotation, METH_VARARGS, "SbSphereSectionProjector_getRotation(SbSphereSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "SbSphereSectionProjector_setTolerance", _wrap_SbSphereSectionProjector_setTolerance, METH_VARARGS, "SbSphereSectionProjector_setTolerance(SbSphereSectionProjector self, float const edgetol)"},
	 { "SbSphereSectionProjector_getTolerance", _wrap_SbSphereSectionProjector_getTolerance, METH_O, "SbSphereSectionProjector_getTolerance(SbSphereSectionProjector self) -> float"},
	 { "SbSphereSectionProjector_setRadialFactor", _wrap_SbSphereSectionProjector_setRadialFactor, METH_VARARGS, "SbSphereSectionProjector_setRadialFactor(SbSphereSectionProjector self, float const rad=0.0)"},
	 { "SbSphereSectionProjector_getRadialFactor", _wrap_SbSphereSectionProjector_getRadialFactor, METH_O, "SbSphereSectionProjector_getRadialFactor(SbSphereSectionProjector self) -> float"},
	 { "SbSphereSectionProjector_isWithinTolerance", _wrap_SbSphereSectionProjector_isWithinTolerance, METH_VARARGS, "SbSphereSectionProjector_isWithinTolerance(SbSphereSectionProjector self, SbVec3f point) -> SbBool"},
	 { "delete_SbSphereSectionProjector", _wrap_delete_SbSphereSectionProjector, METH_O, "delete_SbSphereSectionProjector(SbSphereSectionProjector self)"},
	 { "SbSphereSectionProjector_swigregister", SbSphereSectionProjector_swigregister, METH_O, NULL},
	 { "SbSphereSectionProjector_swiginit", SbSphereSectionProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbSpherePlaneProjector", _wrap_new_SbSpherePlaneProjector, METH_VARARGS, "\n"
		"SbSpherePlaneProjector(float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		"SbSpherePlaneProjector(SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1)\n"
		""},
	 { "SbSpherePlaneProjector_copy", _wrap_SbSpherePlaneProjector_copy, METH_O, "SbSpherePlaneProjector_copy(SbSpherePlaneProjector self) -> SbProjector"},
	 { "SbSpherePlaneProjector_project", _wrap_SbSpherePlaneProjector_project, METH_VARARGS, "SbSpherePlaneProjector_project(SbSpherePlaneProjector self, SbVec2f point) -> SbVec3f"},
	 { "SbSpherePlaneProjector_getRotation", _wrap_SbSpherePlaneProjector_getRotation, METH_VARARGS, "SbSpherePlaneProjector_getRotation(SbSpherePlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"},
	 { "delete_SbSpherePlaneProjector", _wrap_delete_SbSpherePlaneProjector, METH_O, "delete_SbSpherePlaneProjector(SbSpherePlaneProjector self)"},
	 { "SbSpherePlaneProjector_swigregister", SbSpherePlaneProjector_swigregister, METH_O, NULL},
	 { "SbSpherePlaneProjector_swiginit", SbSpherePlaneProjector_swiginit, METH_VARARGS, NULL},
	 { "new_SbClip", _wrap_new_SbClip, METH_VARARGS, "SbClip(SbClipCallback * callback=None, void * userdata=None)"},
	 { "SbClip_addVertex", _wrap_SbClip_addVertex, METH_VARARGS, "SbClip_addVertex(SbClip self, SbVec3f v, void * vdata=None)"},
	 { "SbClip_reset", _wrap_SbClip_reset, METH_O, "SbClip_reset(SbClip self)"},
	 { "SbClip_clip", _wrap_SbClip_clip, METH_VARARGS, "SbClip_clip(SbClip self, SbPlane plane)"},
	 { "SbClip_getNumVertices", _wrap_SbClip_getNumVertices, METH_O, "SbClip_getNumVertices(SbClip self) -> int"},
	 { "SbClip_getVertex", _wrap_SbClip_getVertex, METH_VARARGS, "SbClip_getVertex(SbClip self, int const idx, SbVec3f v, void ** vdata=None)"},
	 { "SbClip_getVertexData", _wrap_SbClip_getVertexData, METH_VARARGS, "SbClip_getVertexData(SbClip self, int const idx) -> void *"},
	 { "delete_SbClip", _wrap_delete_SbClip, METH_O, "delete_SbClip(SbClip self)"},
	 { "SbClip_swigregister", SbClip_swigregister, METH_O, NULL},
	 { "SbClip_swiginit", SbClip_swiginit, METH_VARARGS, NULL},
	 { "new_SbDPRotation", _wrap_new_SbDPRotation, METH_VARARGS, "\n"
		"SbDPRotation()\n"
		"SbDPRotation(SbVec3d axis, double const radians)\n"
		"SbDPRotation(double const [4] q)\n"
		"SbDPRotation(double const q0, double const q1, double const q2, double const q3)\n"
		"SbDPRotation(SbDPMatrix m)\n"
		"new_SbDPRotation(SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation\n"
		""},
	 { "SbDPRotation_getValue", _wrap_SbDPRotation_getValue, METH_O, "SbDPRotation_getValue(SbDPRotation self) -> double const *"},
	 { "SbDPRotation_getAxisAngle", _wrap_SbDPRotation_getAxisAngle, METH_O, "SbDPRotation_getAxisAngle(SbDPRotation self)"},
	 { "SbDPRotation_getMatrix", _wrap_SbDPRotation_getMatrix, METH_O, "SbDPRotation_getMatrix(SbDPRotation self)"},
	 { "SbDPRotation_invert", _wrap_SbDPRotation_invert, METH_O, "SbDPRotation_invert(SbDPRotation self) -> SbDPRotation"},
	 { "SbDPRotation_inverse", _wrap_SbDPRotation_inverse, METH_O, "SbDPRotation_inverse(SbDPRotation self) -> SbDPRotation"},
	 { "SbDPRotation_setValue", _wrap_SbDPRotation_setValue, METH_VARARGS, "\n"
		"SbDPRotation_setValue(SbDPRotation self, double const q0, double const q1, double const q2, double const q3) -> SbDPRotation\n"
		"SbDPRotation_setValue(SbDPRotation self, double const [4] q) -> SbDPRotation\n"
		"SbDPRotation_setValue(SbDPRotation self, SbDPMatrix m) -> SbDPRotation\n"
		"SbDPRotation_setValue(SbDPRotation self, SbVec3d axis, double const radians) -> SbDPRotation\n"
		"SbDPRotation_setValue(SbDPRotation self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation\n"
		""},
	 { "SbDPRotation_equals", _wrap_SbDPRotation_equals, METH_VARARGS, "SbDPRotation_equals(SbDPRotation self, SbDPRotation r, double tolerance) -> SbBool"},
	 { "SbDPRotation_multVec", _wrap_SbDPRotation_multVec, METH_VARARGS, "SbDPRotation_multVec(SbDPRotation self, SbVec3d src, SbVec3d dst)"},
	 { "SbDPRotation_scaleAngle", _wrap_SbDPRotation_scaleAngle, METH_VARARGS, "SbDPRotation_scaleAngle(SbDPRotation self, double const scaleFactor)"},
	 { "SbDPRotation_slerp", _wrap_SbDPRotation_slerp, METH_VARARGS, "SbDPRotation_slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"},
	 { "SbDPRotation_identity", _wrap_SbDPRotation_identity, METH_NOARGS, "SbDPRotation_identity() -> SbDPRotation"},
	 { "SbDPRotation_output", _wrap_SbDPRotation_output, METH_VARARGS, "SbDPRotation_output(SbDPRotation self, FILE * fp)"},
	 { "SbDPRotation___imul__", _wrap_SbDPRotation___imul__, METH_VARARGS, "\n"
		"SbDPRotation___imul__(SbDPRotation self, SbDPRotation q) -> SbDPRotation\n"
		"SbDPRotation___imul__(SbDPRotation self, double const s) -> SbDPRotation\n"
		""},
	 { "SbDPRotation___mul__", _wrap_SbDPRotation___mul__, METH_VARARGS, "\n"
		"SbDPRotation___mul__(SbDPRotation self, SbDPRotation u) -> SbDPRotation\n"
		"SbDPRotation___mul__(SbDPRotation self, double const d) -> SbDPRotation\n"
		"SbDPRotation___mul__(SbDPRotation self, SbVec3d v) -> SbVec3d\n"
		""},
	 { "SbDPRotation___eq__", _wrap_SbDPRotation___eq__, METH_VARARGS, "SbDPRotation___eq__(SbDPRotation self, SbDPRotation u) -> int"},
	 { "SbDPRotation___nq__", _wrap_SbDPRotation___nq__, METH_VARARGS, "SbDPRotation___nq__(SbDPRotation self, SbDPRotation u) -> int"},
	 { "delete_SbDPRotation", _wrap_delete_SbDPRotation, METH_O, "delete_SbDPRotation(SbDPRotation self)"},
	 { "SbDPRotation_swigregister", SbDPRotation_swigregister, METH_O, NULL},
	 { "SbDPRotation_swiginit", SbDPRotation_swiginit, METH_VARARGS, NULL},
	 { "new_SbDPLine", _wrap_new_SbDPLine, METH_VARARGS, "\n"
		"SbDPLine()\n"
		"new_SbDPLine(SbVec3d p0, SbVec3d p1) -> SbDPLine\n"
		""},
	 { "SbDPLine_setValue", _wrap_SbDPLine_setValue, METH_VARARGS, "SbDPLine_setValue(SbDPLine self, SbVec3d p0, SbVec3d p1)"},
	 { "SbDPLine_setPosDir", _wrap_SbDPLine_setPosDir, METH_VARARGS, "SbDPLine_setPosDir(SbDPLine self, SbVec3d position, SbVec3d direction)"},
	 { "SbDPLine_getClosestPoints", _wrap_SbDPLine_getClosestPoints, METH_VARARGS, "SbDPLine_getClosestPoints(SbDPLine self, SbDPLine line2, SbVec3d ptOnThis, SbVec3d ptOnLine2) -> SbBool"},
	 { "SbDPLine_getClosestPoint", _wrap_SbDPLine_getClosestPoint, METH_VARARGS, "SbDPLine_getClosestPoint(SbDPLine self, SbVec3d point) -> SbVec3d"},
	 { "SbDPLine_getPosition", _wrap_SbDPLine_getPosition, METH_O, "SbDPLine_getPosition(SbDPLine self) -> SbVec3d"},
	 { "SbDPLine_getDirection", _wrap_SbDPLine_getDirection, METH_O, "SbDPLine_getDirection(SbDPLine self) -> SbVec3d"},
	 { "SbDPLine_output", _wrap_SbDPLine_output, METH_VARARGS, "SbDPLine_output(SbDPLine self, FILE * file)"},
	 { "delete_SbDPLine", _wrap_delete_SbDPLine, METH_O, "delete_SbDPLine(SbDPLine self)"},
	 { "SbDPLine_swigregister", SbDPLine_swigregister, METH_O, NULL},
	 { "SbDPLine_swiginit", SbDPLine_swiginit, METH_VARARGS, NULL},
	 { "new_SbDPPlane", _wrap_new_SbDPPlane, METH_VARARGS, "\n"
		"SbDPPlane()\n"
		"SbDPPlane(SbVec3d normal, double const D)\n"
		"SbDPPlane(SbVec3d p0, SbVec3d p1, SbVec3d p2)\n"
		"new_SbDPPlane(SbVec3d normal, SbVec3d point) -> SbDPPlane\n"
		""},
	 { "SbDPPlane_offset", _wrap_SbDPPlane_offset, METH_VARARGS, "SbDPPlane_offset(SbDPPlane self, double const d)"},
	 { "SbDPPlane_transform", _wrap_SbDPPlane_transform, METH_O, "SbDPPlane_transform(SbDPPlane self)"},
	 { "SbDPPlane_isInHalfSpace", _wrap_SbDPPlane_isInHalfSpace, METH_VARARGS, "SbDPPlane_isInHalfSpace(SbDPPlane self, SbVec3d point) -> SbBool"},
	 { "SbDPPlane_getDistance", _wrap_SbDPPlane_getDistance, METH_VARARGS, "SbDPPlane_getDistance(SbDPPlane self, SbVec3d point) -> double"},
	 { "SbDPPlane_getNormal", _wrap_SbDPPlane_getNormal, METH_O, "SbDPPlane_getNormal(SbDPPlane self) -> SbVec3d"},
	 { "SbDPPlane_getDistanceFromOrigin", _wrap_SbDPPlane_getDistanceFromOrigin, METH_O, "SbDPPlane_getDistanceFromOrigin(SbDPPlane self) -> double"},
	 { "SbDPPlane_output", _wrap_SbDPPlane_output, METH_VARARGS, "SbDPPlane_output(SbDPPlane self, FILE * file)"},
	 { "SbDPPlane_intersect", _wrap_SbDPPlane_intersect, METH_VARARGS, "\n"
		"SbDPPlane_intersect(SbDPPlane self, SbDPLine l, SbVec3d intersection) -> SbBool\n"
		"SbDPPlane_intersect(SbDPPlane self, SbDPPlane pl, SbDPLine line) -> SbBool\n"
		""},
	 { "SbDPPlane___eq__", _wrap_SbDPPlane___eq__, METH_VARARGS, "SbDPPlane___eq__(SbDPPlane self, SbDPPlane u) -> int"},
	 { "SbDPPlane___ne__", _wrap_SbDPPlane___ne__, METH_VARARGS, "SbDPPlane___ne__(SbDPPlane self, SbDPPlane u) -> int"},
	 { "delete_SbDPPlane", _wrap_delete_SbDPPlane, METH_O, "delete_SbDPPlane(SbDPPlane self)"},
	 { "SbDPPlane_swigregister", SbDPPlane_swigregister, METH_O, NULL},
	 { "SbDPPlane_swiginit", SbDPPlane_swiginit, METH_VARARGS, NULL},
	 { "SbHeapFuncs_eval_func_set", _wrap_SbHeapFuncs_eval_func_set, METH_VARARGS, "SbHeapFuncs_eval_func_set(SbHeapFuncs self, float (*)(void *) eval_func)"},
	 { "SbHeapFuncs_eval_func_get", _wrap_SbHeapFuncs_eval_func_get, METH_O, "SbHeapFuncs_eval_func_get(SbHeapFuncs self) -> float (*)(void *)"},
	 { "SbHeapFuncs_get_index_func_set", _wrap_SbHeapFuncs_get_index_func_set, METH_VARARGS, "SbHeapFuncs_get_index_func_set(SbHeapFuncs self, int (*)(void *) get_index_func)"},
	 { "SbHeapFuncs_get_index_func_get", _wrap_SbHeapFuncs_get_index_func_get, METH_O, "SbHeapFuncs_get_index_func_get(SbHeapFuncs self) -> int (*)(void *)"},
	 { "SbHeapFuncs_set_index_func_set", _wrap_SbHeapFuncs_set_index_func_set, METH_VARARGS, "SbHeapFuncs_set_index_func_set(SbHeapFuncs self, void (*)(void *,int) set_index_func)"},
	 { "SbHeapFuncs_set_index_func_get", _wrap_SbHeapFuncs_set_index_func_get, METH_O, "SbHeapFuncs_set_index_func_get(SbHeapFuncs self) -> void (*)(void *,int)"},
	 { "new_SbHeapFuncs", _wrap_new_SbHeapFuncs, METH_NOARGS, "new_SbHeapFuncs() -> SbHeapFuncs"},
	 { "delete_SbHeapFuncs", _wrap_delete_SbHeapFuncs, METH_O, "delete_SbHeapFuncs(SbHeapFuncs self)"},
	 { "SbHeapFuncs_swigregister", SbHeapFuncs_swigregister, METH_O, NULL},
	 { "SbHeapFuncs_swiginit", SbHeapFuncs_swiginit, METH_VARARGS, NULL},
	 { "new_SbHeap", _wrap_new_SbHeap, METH_VARARGS, "SbHeap(SbHeapFuncs SbHeapFuncs, int const initsize=1024)"},
	 { "delete_SbHeap", _wrap_delete_SbHeap, METH_O, "delete_SbHeap(SbHeap self)"},
	 { "SbHeap_emptyHeap", _wrap_SbHeap_emptyHeap, METH_O, "SbHeap_emptyHeap(SbHeap self)"},
	 { "SbHeap_size", _wrap_SbHeap_size, METH_O, "SbHeap_size(SbHeap self) -> int"},
	 { "SbHeap_add", _wrap_SbHeap_add, METH_VARARGS, "SbHeap_add(SbHeap self, void * obj) -> int"},
	 { "SbHeap_remove", _wrap_SbHeap_remove, METH_VARARGS, "\n"
		"SbHeap_remove(SbHeap self, int const pos)\n"
		"SbHeap_remove(SbHeap self, void * obj)\n"
		""},
	 { "SbHeap_extractMin", _wrap_SbHeap_extractMin, METH_O, "SbHeap_extractMin(SbHeap self) -> void *"},
	 { "SbHeap_getMin", _wrap_SbHeap_getMin, METH_O, "SbHeap_getMin(SbHeap self) -> void *"},
	 { "SbHeap_newWeight", _wrap_SbHeap_newWeight, METH_VARARGS, "SbHeap_newWeight(SbHeap self, void * obj, int hpos=-1)"},
	 { "SbHeap_buildHeap", _wrap_SbHeap_buildHeap, METH_VARARGS, "SbHeap_buildHeap(SbHeap self, SbBool (*)(float,void *) progresscb=None, void * data=None) -> SbBool"},
	 { "SbHeap_traverseHeap", _wrap_SbHeap_traverseHeap, METH_VARARGS, "SbHeap_traverseHeap(SbHeap self, SbBool (*)(void *,void *) func, void * userdata) -> SbBool"},
	 { "SbHeap_swigregister", SbHeap_swigregister, METH_O, NULL},
	 { "SbHeap_swiginit", SbHeap_swiginit, METH_VARARGS, NULL},
	 { "new_SbImage", _wrap_new_SbImage, METH_VARARGS, "\n"
		"SbImage()\n"
		"SbImage(unsigned char const * bytes)\n"
		"SbImage(unsigned char const * bytes)\n"
		"new_SbImage(SbImage image) -> SbImage\n"
		""},
	 { "delete_SbImage", _wrap_delete_SbImage, METH_O, "delete_SbImage(SbImage self)"},
	 { "SbImage_setValue", _wrap_SbImage_setValue, METH_VARARGS, "\n"
		"SbImage_setValue(SbImage self, SbVec2s size)\n"
		"SbImage_setValue(SbImage self, SbVec3s size)\n"
		""},
	 { "SbImage_setValuePtr", _wrap_SbImage_setValuePtr, METH_VARARGS, "\n"
		"SbImage_setValuePtr(SbImage self, SbVec2s size)\n"
		"SbImage_setValuePtr(SbImage self, SbVec3s size)\n"
		""},
	 { "SbImage_getSize", _wrap_SbImage_getSize, METH_O, "SbImage_getSize(SbImage self) -> SbVec3s"},
	 { "SbImage_readFile", _wrap_SbImage_readFile, METH_VARARGS, "SbImage_readFile(SbImage self, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"},
	 { "SbImage___eq__", _wrap_SbImage___eq__, METH_VARARGS, "SbImage___eq__(SbImage self, SbImage image) -> int"},
	 { "SbImage___ne__", _wrap_SbImage___ne__, METH_VARARGS, "SbImage___ne__(SbImage self, SbImage image) -> int"},
	 { "SbImage_addReadImageCB", _wrap_SbImage_addReadImageCB, METH_VARARGS, "SbImage_addReadImageCB(SbImageReadImageCB * cb, void * closure)"},
	 { "SbImage_removeReadImageCB", _wrap_SbImage_removeReadImageCB, METH_VARARGS, "SbImage_removeReadImageCB(SbImageReadImageCB * cb, void * closure)"},
	 { "SbImage_searchForFile", _wrap_SbImage_searchForFile, METH_VARARGS, "SbImage_searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"},
	 { "SbImage_hasData", _wrap_SbImage_hasData, METH_O, "SbImage_hasData(SbImage self) -> SbBool"},
	 { "SbImage_readLock", _wrap_SbImage_readLock, METH_O, "SbImage_readLock(SbImage self)"},
	 { "SbImage_readUnlock", _wrap_SbImage_readUnlock, METH_O, "SbImage_readUnlock(SbImage self)"},
	 { "SbImage_scheduleReadFile", _wrap_SbImage_scheduleReadFile, METH_VARARGS, "SbImage_scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"},
	 { "SbImage_getValue", _wrap_SbImage_getValue, METH_VARARGS, "\n"
		"SbImage_getValue(SbImage self, SbVec2s size, int & bytesperpixel) -> unsigned char\n"
		"SbImage_getValue(SbImage self, SbVec3s size, int & bytesperpixel) -> unsigned char\n"
		"SbImage_getValue(SbImage self) -> PyObject *\n"
		""},
	 { "SbImage_swigregister", SbImage_swigregister, METH_O, NULL},
	 { "SbImage_swiginit", SbImage_swiginit, METH_VARARGS, NULL},
	 { "SbOctTreeFuncs_ptinsidefunc_set", _wrap_SbOctTreeFuncs_ptinsidefunc_set, METH_VARARGS, "SbOctTreeFuncs_ptinsidefunc_set(SbOctTreeFuncs self, SbBool (*)(void *const,SbVec3f const &) ptinsidefunc)"},
	 { "SbOctTreeFuncs_ptinsidefunc_get", _wrap_SbOctTreeFuncs_ptinsidefunc_get, METH_O, "SbOctTreeFuncs_ptinsidefunc_get(SbOctTreeFuncs self) -> SbBool (*)(void *const,SbVec3f const &)"},
	 { "SbOctTreeFuncs_insideboxfunc_set", _wrap_SbOctTreeFuncs_insideboxfunc_set, METH_VARARGS, "SbOctTreeFuncs_insideboxfunc_set(SbOctTreeFuncs self, SbBool (*)(void *const,SbBox3f const &) insideboxfunc)"},
	 { "SbOctTreeFuncs_insideboxfunc_get", _wrap_SbOctTreeFuncs_insideboxfunc_get, METH_O, "SbOctTreeFuncs_insideboxfunc_get(SbOctTreeFuncs self) -> SbBool (*)(void *const,SbBox3f const &)"},
	 { "SbOctTreeFuncs_insidespherefunc_set", _wrap_SbOctTreeFuncs_insidespherefunc_set, METH_VARARGS, "SbOctTreeFuncs_insidespherefunc_set(SbOctTreeFuncs self, SbBool (*)(void *const,SbSphere const &) insidespherefunc)"},
	 { "SbOctTreeFuncs_insidespherefunc_get", _wrap_SbOctTreeFuncs_insidespherefunc_get, METH_O, "SbOctTreeFuncs_insidespherefunc_get(SbOctTreeFuncs self) -> SbBool (*)(void *const,SbSphere const &)"},
	 { "SbOctTreeFuncs_insideplanesfunc_set", _wrap_SbOctTreeFuncs_insideplanesfunc_set, METH_VARARGS, "SbOctTreeFuncs_insideplanesfunc_set(SbOctTreeFuncs self, SbBool (*)(void *const,SbPlane const *const,int const) insideplanesfunc)"},
	 { "SbOctTreeFuncs_insideplanesfunc_get", _wrap_SbOctTreeFuncs_insideplanesfunc_get, METH_O, "SbOctTreeFuncs_insideplanesfunc_get(SbOctTreeFuncs self) -> SbBool (*)(void *const,SbPlane const *const,int const)"},
	 { "new_SbOctTreeFuncs", _wrap_new_SbOctTreeFuncs, METH_NOARGS, "new_SbOctTreeFuncs() -> SbOctTreeFuncs"},
	 { "delete_SbOctTreeFuncs", _wrap_delete_SbOctTreeFuncs, METH_O, "delete_SbOctTreeFuncs(SbOctTreeFuncs self)"},
	 { "SbOctTreeFuncs_swigregister", SbOctTreeFuncs_swigregister, METH_O, NULL},
	 { "SbOctTreeFuncs_swiginit", SbOctTreeFuncs_swiginit, METH_VARARGS, NULL},
	 { "new_SbOctTree", _wrap_new_SbOctTree, METH_VARARGS, "SbOctTree(SbBox3f bbox, SbOctTreeFuncs itemfuncs, int const maxitemspernode=64)"},
	 { "delete_SbOctTree", _wrap_delete_SbOctTree, METH_O, "delete_SbOctTree(SbOctTree self)"},
	 { "SbOctTree_addItem", _wrap_SbOctTree_addItem, METH_VARARGS, "SbOctTree_addItem(SbOctTree self, void *const item)"},
	 { "SbOctTree_removeItem", _wrap_SbOctTree_removeItem, METH_VARARGS, "SbOctTree_removeItem(SbOctTree self, void *const item)"},
	 { "SbOctTree_findItems", _wrap_SbOctTree_findItems, METH_VARARGS, "\n"
		"SbOctTree_findItems(SbOctTree self, SbVec3f pos, SbList< void * > & destarray, SbBool const removeduplicates=1)\n"
		"SbOctTree_findItems(SbOctTree self, SbBox3f box, SbList< void * > & destarray, SbBool const removeduplicates=1)\n"
		"SbOctTree_findItems(SbOctTree self, SbSphere sphere, SbList< void * > & destarray, SbBool const removeduplicates=1)\n"
		"SbOctTree_findItems(SbOctTree self, SbPlane planes, int const numplanes, SbList< void * > & destarray, SbBool const removeduplicates=1)\n"
		""},
	 { "SbOctTree_getBoundingBox", _wrap_SbOctTree_getBoundingBox, METH_O, "SbOctTree_getBoundingBox(SbOctTree self) -> SbBox3f"},
	 { "SbOctTree_clear", _wrap_SbOctTree_clear, METH_O, "SbOctTree_clear(SbOctTree self)"},
	 { "SbOctTree_debugTree", _wrap_SbOctTree_debugTree, METH_VARARGS, "SbOctTree_debugTree(SbOctTree self, FILE * fp)"},
	 { "SbOctTree_swigregister", SbOctTree_swigregister, METH_O, NULL},
	 { "SbOctTree_swiginit", SbOctTree_swiginit, METH_VARARGS, NULL},
	 { "new_SbTesselator", _wrap_new_SbTesselator, METH_VARARGS, "SbTesselator(SbTesselatorCB * func=None, void * data=None)"},
	 { "delete_SbTesselator", _wrap_delete_SbTesselator, METH_O, "delete_SbTesselator(SbTesselator self)"},
	 { "SbTesselator_beginPolygon", _wrap_SbTesselator_beginPolygon, METH_VARARGS, "SbTesselator_beginPolygon(SbTesselator self, SbBool keepVertices=0, SbVec3f normal=SbVec3f(0.0f, 0.0f, 0.0f))"},
	 { "SbTesselator_addVertex", _wrap_SbTesselator_addVertex, METH_VARARGS, "SbTesselator_addVertex(SbTesselator self, SbVec3f v, void * data)"},
	 { "SbTesselator_endPolygon", _wrap_SbTesselator_endPolygon, METH_O, "SbTesselator_endPolygon(SbTesselator self)"},
	 { "SbTesselator_setCallback", _wrap_SbTesselator_setCallback, METH_VARARGS, "SbTesselator_setCallback(SbTesselator self, SbTesselatorCB * func, void * data)"},
	 { "SbTesselator_swigregister", SbTesselator_swigregister, METH_O, NULL},
	 { "SbTesselator_swiginit", SbTesselator_swiginit, METH_VARARGS, NULL},
	 { "new_SoTimerQueueSensor", _wrap_new_SoTimerQueueSensor, METH_NOARGS, "new_SoTimerQueueSensor() -> SoTimerQueueSensor"},
	 { "new_SoTimerQueueSensor_scb_v", _wrap_new_SoTimerQueueSensor_scb_v, METH_VARARGS, "new_SoTimerQueueSensor_scb_v(SoSensorCB * func, void * data) -> SoTimerQueueSensor"},
	 { "delete_SoTimerQueueSensor", _wrap_delete_SoTimerQueueSensor, METH_O, "delete_SoTimerQueueSensor(SoTimerQueueSensor self)"},
	 { "SoTimerQueueSensor_getTriggerTime", _wrap_SoTimerQueueSensor_getTriggerTime, METH_O, "SoTimerQueueSensor_getTriggerTime(SoTimerQueueSensor self) -> SbTime"},
	 { "SoTimerQueueSensor_schedule", _wrap_SoTimerQueueSensor_schedule, METH_O, "SoTimerQueueSensor_schedule(SoTimerQueueSensor self)"},
	 { "SoTimerQueueSensor_unschedule", _wrap_SoTimerQueueSensor_unschedule, METH_O, "SoTimerQueueSensor_unschedule(SoTimerQueueSensor self)"},
	 { "SoTimerQueueSensor_isScheduled", _wrap_SoTimerQueueSensor_isScheduled, METH_O, "SoTimerQueueSensor_isScheduled(SoTimerQueueSensor self) -> SbBool"},
	 { "SoTimerQueueSensor_trigger", _wrap_SoTimerQueueSensor_trigger, METH_O, "SoTimerQueueSensor_trigger(SoTimerQueueSensor self)"},
	 { "SoTimerQueueSensor_swigregister", SoTimerQueueSensor_swigregister, METH_O, NULL},
	 { "SoTimerQueueSensor_swiginit", SoTimerQueueSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoAlarmSensor", _wrap_new_SoAlarmSensor, METH_NOARGS, "new_SoAlarmSensor() -> SoAlarmSensor"},
	 { "new_SoAlarmSensor_scb_v", _wrap_new_SoAlarmSensor_scb_v, METH_VARARGS, "new_SoAlarmSensor_scb_v(SoSensorCB * func, void * data) -> SoAlarmSensor"},
	 { "delete_SoAlarmSensor", _wrap_delete_SoAlarmSensor, METH_O, "delete_SoAlarmSensor(SoAlarmSensor self)"},
	 { "SoAlarmSensor_setTime", _wrap_SoAlarmSensor_setTime, METH_VARARGS, "SoAlarmSensor_setTime(SoAlarmSensor self, SbTime abstime)"},
	 { "SoAlarmSensor_setTimeFromNow", _wrap_SoAlarmSensor_setTimeFromNow, METH_VARARGS, "SoAlarmSensor_setTimeFromNow(SoAlarmSensor self, SbTime reltime)"},
	 { "SoAlarmSensor_getTime", _wrap_SoAlarmSensor_getTime, METH_O, "SoAlarmSensor_getTime(SoAlarmSensor self) -> SbTime"},
	 { "SoAlarmSensor_schedule", _wrap_SoAlarmSensor_schedule, METH_O, "SoAlarmSensor_schedule(SoAlarmSensor self)"},
	 { "SoAlarmSensor_swigregister", SoAlarmSensor_swigregister, METH_O, NULL},
	 { "SoAlarmSensor_swiginit", SoAlarmSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoIdleSensor", _wrap_new_SoIdleSensor, METH_NOARGS, "new_SoIdleSensor() -> SoIdleSensor"},
	 { "new_SoIdleSensor_scb_v", _wrap_new_SoIdleSensor_scb_v, METH_VARARGS, "new_SoIdleSensor_scb_v(SoSensorCB * func, void * data) -> SoIdleSensor"},
	 { "delete_SoIdleSensor", _wrap_delete_SoIdleSensor, METH_O, "delete_SoIdleSensor(SoIdleSensor self)"},
	 { "SoIdleSensor_swigregister", SoIdleSensor_swigregister, METH_O, NULL},
	 { "SoIdleSensor_swiginit", SoIdleSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoNodeSensor", _wrap_new_SoNodeSensor, METH_NOARGS, "new_SoNodeSensor() -> SoNodeSensor"},
	 { "new_SoNodeSensor_scb_v", _wrap_new_SoNodeSensor_scb_v, METH_VARARGS, "new_SoNodeSensor_scb_v(SoSensorCB * func, void * data) -> SoNodeSensor"},
	 { "delete_SoNodeSensor", _wrap_delete_SoNodeSensor, METH_O, "delete_SoNodeSensor(SoNodeSensor self)"},
	 { "SoNodeSensor_attach", _wrap_SoNodeSensor_attach, METH_VARARGS, "SoNodeSensor_attach(SoNodeSensor self, SoNode node)"},
	 { "SoNodeSensor_detach", _wrap_SoNodeSensor_detach, METH_O, "SoNodeSensor_detach(SoNodeSensor self)"},
	 { "SoNodeSensor_getAttachedNode", _wrap_SoNodeSensor_getAttachedNode, METH_O, "SoNodeSensor_getAttachedNode(SoNodeSensor self) -> SoNode"},
	 { "SoNodeSensor_swigregister", SoNodeSensor_swigregister, METH_O, NULL},
	 { "SoNodeSensor_swiginit", SoNodeSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoOneShotSensor", _wrap_new_SoOneShotSensor, METH_NOARGS, "new_SoOneShotSensor() -> SoOneShotSensor"},
	 { "new_SoOneShotSensor_scb_v", _wrap_new_SoOneShotSensor_scb_v, METH_VARARGS, "new_SoOneShotSensor_scb_v(SoSensorCB * func, void * data) -> SoOneShotSensor"},
	 { "delete_SoOneShotSensor", _wrap_delete_SoOneShotSensor, METH_O, "delete_SoOneShotSensor(SoOneShotSensor self)"},
	 { "SoOneShotSensor_swigregister", SoOneShotSensor_swigregister, METH_O, NULL},
	 { "SoOneShotSensor_swiginit", SoOneShotSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoPathSensor", _wrap_new_SoPathSensor, METH_NOARGS, "new_SoPathSensor() -> SoPathSensor"},
	 { "new_SoPathSensor_scb_v", _wrap_new_SoPathSensor_scb_v, METH_VARARGS, "new_SoPathSensor_scb_v(SoSensorCB * func, void * data) -> SoPathSensor"},
	 { "delete_SoPathSensor", _wrap_delete_SoPathSensor, METH_O, "delete_SoPathSensor(SoPathSensor self)"},
	 { "SoPathSensor_setTriggerFilter", _wrap_SoPathSensor_setTriggerFilter, METH_VARARGS, "SoPathSensor_setTriggerFilter(SoPathSensor self, SoPathSensor::TriggerFilter const type)"},
	 { "SoPathSensor_getTriggerFilter", _wrap_SoPathSensor_getTriggerFilter, METH_O, "SoPathSensor_getTriggerFilter(SoPathSensor self) -> SoPathSensor::TriggerFilter"},
	 { "SoPathSensor_attach", _wrap_SoPathSensor_attach, METH_VARARGS, "SoPathSensor_attach(SoPathSensor self, SoPath path)"},
	 { "SoPathSensor_detach", _wrap_SoPathSensor_detach, METH_O, "SoPathSensor_detach(SoPathSensor self)"},
	 { "SoPathSensor_getAttachedPath", _wrap_SoPathSensor_getAttachedPath, METH_O, "SoPathSensor_getAttachedPath(SoPathSensor self) -> SoPath"},
	 { "SoPathSensor_swigregister", SoPathSensor_swigregister, METH_O, NULL},
	 { "SoPathSensor_swiginit", SoPathSensor_swiginit, METH_VARARGS, NULL},
	 { "new_SoTimerSensor", _wrap_new_SoTimerSensor, METH_NOARGS, "new_SoTimerSensor() -> SoTimerSensor"},
	 { "new_SoTimerSensor_scb_v", _wrap_new_SoTimerSensor_scb_v, METH_VARARGS, "new_SoTimerSensor_scb_v(SoSensorCB * func, void * data) -> SoTimerSensor"},
	 { "delete_SoTimerSensor", _wrap_delete_SoTimerSensor, METH_O, "delete_SoTimerSensor(SoTimerSensor self)"},
	 { "SoTimerSensor_setBaseTime", _wrap_SoTimerSensor_setBaseTime, METH_VARARGS, "SoTimerSensor_setBaseTime(SoTimerSensor self, SbTime base)"},
	 { "SoTimerSensor_getBaseTime", _wrap_SoTimerSensor_getBaseTime, METH_O, "SoTimerSensor_getBaseTime(SoTimerSensor self) -> SbTime"},
	 { "SoTimerSensor_setInterval", _wrap_SoTimerSensor_setInterval, METH_VARARGS, "SoTimerSensor_setInterval(SoTimerSensor self, SbTime interval)"},
	 { "SoTimerSensor_getInterval", _wrap_SoTimerSensor_getInterval, METH_O, "SoTimerSensor_getInterval(SoTimerSensor self) -> SbTime"},
	 { "SoTimerSensor_schedule", _wrap_SoTimerSensor_schedule, METH_O, "SoTimerSensor_schedule(SoTimerSensor self)"},
	 { "SoTimerSensor_unschedule", _wrap_SoTimerSensor_unschedule, METH_O, "SoTimerSensor_unschedule(SoTimerSensor self)"},
	 { "SoTimerSensor_reschedule", _wrap_SoTimerSensor_reschedule, METH_VARARGS, "SoTimerSensor_reschedule(SoTimerSensor self, SbTime schedtime)"},
	 { "SoTimerSensor_swigregister", SoTimerSensor_swigregister, METH_O, NULL},
	 { "SoTimerSensor_swiginit", SoTimerSensor_swiginit, METH_VARARGS, NULL},
	 { "SoInteraction_init", _wrap_SoInteraction_init, METH_NOARGS, "SoInteraction_init()"},
	 { "new_SoInteraction", _wrap_new_SoInteraction, METH_NOARGS, "new_SoInteraction() -> SoInteraction"},
	 { "delete_SoInteraction", _wrap_delete_SoInteraction, METH_O, "delete_SoInteraction(SoInteraction self)"},
	 { "SoInteraction_swigregister", SoInteraction_swigregister, METH_O, NULL},
	 { "SoInteraction_swiginit", SoInteraction_swiginit, METH_VARARGS, NULL},
	 { "new_SoOffscreenRenderer", _wrap_new_SoOffscreenRenderer, METH_VARARGS, "\n"
		"SoOffscreenRenderer(SbViewportRegion viewportregion)\n"
		"new_SoOffscreenRenderer(SoGLRenderAction action) -> SoOffscreenRenderer\n"
		""},
	 { "delete_SoOffscreenRenderer", _wrap_delete_SoOffscreenRenderer, METH_O, "delete_SoOffscreenRenderer(SoOffscreenRenderer self)"},
	 { "SoOffscreenRenderer_getScreenPixelsPerInch", _wrap_SoOffscreenRenderer_getScreenPixelsPerInch, METH_NOARGS, "SoOffscreenRenderer_getScreenPixelsPerInch() -> float"},
	 { "SoOffscreenRenderer_getMaximumResolution", _wrap_SoOffscreenRenderer_getMaximumResolution, METH_NOARGS, "SoOffscreenRenderer_getMaximumResolution() -> SbVec2s"},
	 { "SoOffscreenRenderer_setComponents", _wrap_SoOffscreenRenderer_setComponents, METH_VARARGS, "SoOffscreenRenderer_setComponents(SoOffscreenRenderer self, SoOffscreenRenderer::Components const components)"},
	 { "SoOffscreenRenderer_getComponents", _wrap_SoOffscreenRenderer_getComponents, METH_O, "SoOffscreenRenderer_getComponents(SoOffscreenRenderer self) -> SoOffscreenRenderer::Components"},
	 { "SoOffscreenRenderer_setViewportRegion", _wrap_SoOffscreenRenderer_setViewportRegion, METH_VARARGS, "SoOffscreenRenderer_setViewportRegion(SoOffscreenRenderer self, SbViewportRegion region)"},
	 { "SoOffscreenRenderer_getViewportRegion", _wrap_SoOffscreenRenderer_getViewportRegion, METH_O, "SoOffscreenRenderer_getViewportRegion(SoOffscreenRenderer self) -> SbViewportRegion"},
	 { "SoOffscreenRenderer_setBackgroundColor", _wrap_SoOffscreenRenderer_setBackgroundColor, METH_VARARGS, "SoOffscreenRenderer_setBackgroundColor(SoOffscreenRenderer self, SbColor color)"},
	 { "SoOffscreenRenderer_getBackgroundColor", _wrap_SoOffscreenRenderer_getBackgroundColor, METH_O, "SoOffscreenRenderer_getBackgroundColor(SoOffscreenRenderer self) -> SbColor"},
	 { "SoOffscreenRenderer_setGLRenderAction", _wrap_SoOffscreenRenderer_setGLRenderAction, METH_VARARGS, "SoOffscreenRenderer_setGLRenderAction(SoOffscreenRenderer self, SoGLRenderAction action)"},
	 { "SoOffscreenRenderer_getGLRenderAction", _wrap_SoOffscreenRenderer_getGLRenderAction, METH_O, "SoOffscreenRenderer_getGLRenderAction(SoOffscreenRenderer self) -> SoGLRenderAction"},
	 { "SoOffscreenRenderer_render", _wrap_SoOffscreenRenderer_render, METH_VARARGS, "\n"
		"SoOffscreenRenderer_render(SoOffscreenRenderer self, SoNode scene) -> SbBool\n"
		"SoOffscreenRenderer_render(SoOffscreenRenderer self, SoPath scene) -> SbBool\n"
		""},
	 { "SoOffscreenRenderer_getDC", _wrap_SoOffscreenRenderer_getDC, METH_O, "SoOffscreenRenderer_getDC(SoOffscreenRenderer self) -> void const *const &"},
	 { "SoOffscreenRenderer_writeToRGB", _wrap_SoOffscreenRenderer_writeToRGB, METH_VARARGS, "\n"
		"SoOffscreenRenderer_writeToRGB(SoOffscreenRenderer self, FILE * fp) -> SbBool\n"
		"SoOffscreenRenderer_writeToRGB(SoOffscreenRenderer self, char const * filename) -> SbBool\n"
		""},
	 { "SoOffscreenRenderer_writeToPostScript", _wrap_SoOffscreenRenderer_writeToPostScript, METH_VARARGS, "\n"
		"SoOffscreenRenderer_writeToPostScript(SoOffscreenRenderer self, FILE * fp) -> SbBool\n"
		"SoOffscreenRenderer_writeToPostScript(SoOffscreenRenderer self, FILE * fp, SbVec2f printsize) -> SbBool\n"
		"SoOffscreenRenderer_writeToPostScript(SoOffscreenRenderer self, char const * filename) -> SbBool\n"
		"SoOffscreenRenderer_writeToPostScript(SoOffscreenRenderer self, char const * filename, SbVec2f printsize) -> SbBool\n"
		""},
	 { "SoOffscreenRenderer_isWriteSupported", _wrap_SoOffscreenRenderer_isWriteSupported, METH_VARARGS, "SoOffscreenRenderer_isWriteSupported(SoOffscreenRenderer self, SbName filetypeextension) -> SbBool"},
	 { "SoOffscreenRenderer_getNumWriteFiletypes", _wrap_SoOffscreenRenderer_getNumWriteFiletypes, METH_O, "SoOffscreenRenderer_getNumWriteFiletypes(SoOffscreenRenderer self) -> int"},
	 { "SoOffscreenRenderer_getWriteFiletypeInfo", _wrap_SoOffscreenRenderer_getWriteFiletypeInfo, METH_VARARGS, "SoOffscreenRenderer_getWriteFiletypeInfo(SoOffscreenRenderer self, int const idx, SbPList extlist, SbString fullname, SbString description)"},
	 { "SoOffscreenRenderer_writeToFile", _wrap_SoOffscreenRenderer_writeToFile, METH_VARARGS, "SoOffscreenRenderer_writeToFile(SoOffscreenRenderer self, SbString filename, SbName filetypeextension) -> SbBool"},
	 { "SoOffscreenRenderer_setPbufferEnable", _wrap_SoOffscreenRenderer_setPbufferEnable, METH_VARARGS, "SoOffscreenRenderer_setPbufferEnable(SoOffscreenRenderer self, SbBool enable)"},
	 { "SoOffscreenRenderer_getPbufferEnable", _wrap_SoOffscreenRenderer_getPbufferEnable, METH_O, "SoOffscreenRenderer_getPbufferEnable(SoOffscreenRenderer self) -> SbBool"},
	 { "SoOffscreenRenderer_getBuffer", _wrap_SoOffscreenRenderer_getBuffer, METH_VARARGS, "\n"
		"SoOffscreenRenderer_getBuffer(SoOffscreenRenderer self) -> unsigned char\n"
		"SoOffscreenRenderer_getBuffer(SoOffscreenRenderer self) -> PyObject *\n"
		""},
	 { "SoOffscreenRenderer_swigregister", SoOffscreenRenderer_swigregister, METH_O, NULL},
	 { "SoOffscreenRenderer_swiginit", SoOffscreenRenderer_swiginit, METH_VARARGS, NULL},
	 { "new_SoPickedPoint", _wrap_new_SoPickedPoint, METH_VARARGS, "\n"
		"SoPickedPoint(SoPickedPoint pp)\n"
		"new_SoPickedPoint(SoPath path, SoState state, SbVec3f objSpacePoint) -> SoPickedPoint\n"
		""},
	 { "delete_SoPickedPoint", _wrap_delete_SoPickedPoint, METH_O, "delete_SoPickedPoint(SoPickedPoint self)"},
	 { "SoPickedPoint_copy", _wrap_SoPickedPoint_copy, METH_O, "SoPickedPoint_copy(SoPickedPoint self) -> SoPickedPoint"},
	 { "SoPickedPoint_getPoint", _wrap_SoPickedPoint_getPoint, METH_O, "SoPickedPoint_getPoint(SoPickedPoint self) -> SbVec3f"},
	 { "SoPickedPoint_getNormal", _wrap_SoPickedPoint_getNormal, METH_O, "SoPickedPoint_getNormal(SoPickedPoint self) -> SbVec3f"},
	 { "SoPickedPoint_getTextureCoords", _wrap_SoPickedPoint_getTextureCoords, METH_O, "SoPickedPoint_getTextureCoords(SoPickedPoint self) -> SbVec4f"},
	 { "SoPickedPoint_getMaterialIndex", _wrap_SoPickedPoint_getMaterialIndex, METH_O, "SoPickedPoint_getMaterialIndex(SoPickedPoint self) -> int"},
	 { "SoPickedPoint_getPath", _wrap_SoPickedPoint_getPath, METH_O, "SoPickedPoint_getPath(SoPickedPoint self) -> SoPath"},
	 { "SoPickedPoint_isOnGeometry", _wrap_SoPickedPoint_isOnGeometry, METH_O, "SoPickedPoint_isOnGeometry(SoPickedPoint self) -> SbBool"},
	 { "SoPickedPoint_getDetail", _wrap_SoPickedPoint_getDetail, METH_VARARGS, "SoPickedPoint_getDetail(SoPickedPoint self, SoNode node=None) -> SoDetail"},
	 { "SoPickedPoint_getObjectToWorld", _wrap_SoPickedPoint_getObjectToWorld, METH_VARARGS, "SoPickedPoint_getObjectToWorld(SoPickedPoint self, SoNode node=None) -> SbMatrix"},
	 { "SoPickedPoint_getWorldToObject", _wrap_SoPickedPoint_getWorldToObject, METH_VARARGS, "SoPickedPoint_getWorldToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"},
	 { "SoPickedPoint_getObjectToImage", _wrap_SoPickedPoint_getObjectToImage, METH_VARARGS, "SoPickedPoint_getObjectToImage(SoPickedPoint self, SoNode node=None) -> SbMatrix"},
	 { "SoPickedPoint_getImageToObject", _wrap_SoPickedPoint_getImageToObject, METH_VARARGS, "SoPickedPoint_getImageToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"},
	 { "SoPickedPoint_getObjectPoint", _wrap_SoPickedPoint_getObjectPoint, METH_VARARGS, "SoPickedPoint_getObjectPoint(SoPickedPoint self, SoNode node=None) -> SbVec3f"},
	 { "SoPickedPoint_getObjectNormal", _wrap_SoPickedPoint_getObjectNormal, METH_VARARGS, "SoPickedPoint_getObjectNormal(SoPickedPoint self, SoNode node=None) -> SbVec3f"},
	 { "SoPickedPoint_getObjectTextureCoords", _wrap_SoPickedPoint_getObjectTextureCoords, METH_VARARGS, "SoPickedPoint_getObjectTextureCoords(SoPickedPoint self, SoNode node=None) -> SbVec4f"},
	 { "SoPickedPoint_setObjectNormal", _wrap_SoPickedPoint_setObjectNormal, METH_VARARGS, "SoPickedPoint_setObjectNormal(SoPickedPoint self, SbVec3f normal)"},
	 { "SoPickedPoint_setObjectTextureCoords", _wrap_SoPickedPoint_setObjectTextureCoords, METH_VARARGS, "SoPickedPoint_setObjectTextureCoords(SoPickedPoint self, SbVec4f texCoords)"},
	 { "SoPickedPoint_setMaterialIndex", _wrap_SoPickedPoint_setMaterialIndex, METH_VARARGS, "SoPickedPoint_setMaterialIndex(SoPickedPoint self, int const index)"},
	 { "SoPickedPoint_setDetail", _wrap_SoPickedPoint_setDetail, METH_VARARGS, "SoPickedPoint_setDetail(SoPickedPoint self, SoDetail detail, SoNode node)"},
	 { "SoPickedPoint_swigregister", SoPickedPoint_swigregister, METH_O, NULL},
	 { "SoPickedPoint_swiginit", SoPickedPoint_swiginit, METH_VARARGS, NULL},
	 { "new_SoPrimitiveVertex", _wrap_new_SoPrimitiveVertex, METH_VARARGS, "\n"
		"SoPrimitiveVertex()\n"
		"new_SoPrimitiveVertex(SoPrimitiveVertex pv) -> SoPrimitiveVertex\n"
		""},
	 { "delete_SoPrimitiveVertex", _wrap_delete_SoPrimitiveVertex, METH_O, "delete_SoPrimitiveVertex(SoPrimitiveVertex self)"},
	 { "SoPrimitiveVertex_getPoint", _wrap_SoPrimitiveVertex_getPoint, METH_O, "SoPrimitiveVertex_getPoint(SoPrimitiveVertex self) -> SbVec3f"},
	 { "SoPrimitiveVertex_getNormal", _wrap_SoPrimitiveVertex_getNormal, METH_O, "SoPrimitiveVertex_getNormal(SoPrimitiveVertex self) -> SbVec3f"},
	 { "SoPrimitiveVertex_getTextureCoords", _wrap_SoPrimitiveVertex_getTextureCoords, METH_O, "SoPrimitiveVertex_getTextureCoords(SoPrimitiveVertex self) -> SbVec4f"},
	 { "SoPrimitiveVertex_getMaterialIndex", _wrap_SoPrimitiveVertex_getMaterialIndex, METH_O, "SoPrimitiveVertex_getMaterialIndex(SoPrimitiveVertex self) -> int"},
	 { "SoPrimitiveVertex_getPackedColor", _wrap_SoPrimitiveVertex_getPackedColor, METH_O, "SoPrimitiveVertex_getPackedColor(SoPrimitiveVertex self) -> uint32_t"},
	 { "SoPrimitiveVertex_getDetail", _wrap_SoPrimitiveVertex_getDetail, METH_O, "SoPrimitiveVertex_getDetail(SoPrimitiveVertex self) -> SoDetail"},
	 { "SoPrimitiveVertex_setPoint", _wrap_SoPrimitiveVertex_setPoint, METH_VARARGS, "\n"
		"SoPrimitiveVertex_setPoint(SoPrimitiveVertex self, SbVec3f pt)\n"
		"SoPrimitiveVertex_setPoint(SoPrimitiveVertex self, float x, float y, float z)\n"
		""},
	 { "SoPrimitiveVertex_setNormal", _wrap_SoPrimitiveVertex_setNormal, METH_VARARGS, "\n"
		"SoPrimitiveVertex_setNormal(SoPrimitiveVertex self, SbVec3f n)\n"
		"SoPrimitiveVertex_setNormal(SoPrimitiveVertex self, float nx, float ny, float nz)\n"
		""},
	 { "SoPrimitiveVertex_setTextureCoords", _wrap_SoPrimitiveVertex_setTextureCoords, METH_VARARGS, "\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, SbVec2f tex)\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, float tx, float ty)\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, SbVec3f tex)\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz)\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, SbVec4f tex)\n"
		"SoPrimitiveVertex_setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz, float tw)\n"
		""},
	 { "SoPrimitiveVertex_setMaterialIndex", _wrap_SoPrimitiveVertex_setMaterialIndex, METH_VARARGS, "SoPrimitiveVertex_setMaterialIndex(SoPrimitiveVertex self, int index)"},
	 { "SoPrimitiveVertex_setPackedColor", _wrap_SoPrimitiveVertex_setPackedColor, METH_VARARGS, "SoPrimitiveVertex_setPackedColor(SoPrimitiveVertex self, uint32_t rgba)"},
	 { "SoPrimitiveVertex_setDetail", _wrap_SoPrimitiveVertex_setDetail, METH_VARARGS, "SoPrimitiveVertex_setDetail(SoPrimitiveVertex self, SoDetail d)"},
	 { "SoPrimitiveVertex_swigregister", SoPrimitiveVertex_swigregister, METH_O, NULL},
	 { "SoPrimitiveVertex_swiginit", SoPrimitiveVertex_swiginit, METH_VARARGS, NULL},
	 { "new_SoSceneManager", _wrap_new_SoSceneManager, METH_NOARGS, "new_SoSceneManager() -> SoSceneManager"},
	 { "delete_SoSceneManager", _wrap_delete_SoSceneManager, METH_O, "delete_SoSceneManager(SoSceneManager self)"},
	 { "SoSceneManager_render", _wrap_SoSceneManager_render, METH_VARARGS, "\n"
		"SoSceneManager_render(SoSceneManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)\n"
		"SoSceneManager_render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)\n"
		""},
	 { "SoSceneManager_setCamera", _wrap_SoSceneManager_setCamera, METH_VARARGS, "SoSceneManager_setCamera(SoSceneManager self, SoCamera camera)"},
	 { "SoSceneManager_getCamera", _wrap_SoSceneManager_getCamera, METH_O, "SoSceneManager_getCamera(SoSceneManager self) -> SoCamera"},
	 { "SoSceneManager_processEvent", _wrap_SoSceneManager_processEvent, METH_VARARGS, "SoSceneManager_processEvent(SoSceneManager self, SoEvent event) -> SbBool"},
	 { "SoSceneManager_reinitialize", _wrap_SoSceneManager_reinitialize, METH_O, "SoSceneManager_reinitialize(SoSceneManager self)"},
	 { "SoSceneManager_scheduleRedraw", _wrap_SoSceneManager_scheduleRedraw, METH_O, "SoSceneManager_scheduleRedraw(SoSceneManager self)"},
	 { "SoSceneManager_setSceneGraph", _wrap_SoSceneManager_setSceneGraph, METH_VARARGS, "SoSceneManager_setSceneGraph(SoSceneManager self, SoNode sceneroot)"},
	 { "SoSceneManager_getSceneGraph", _wrap_SoSceneManager_getSceneGraph, METH_O, "SoSceneManager_getSceneGraph(SoSceneManager self) -> SoNode"},
	 { "SoSceneManager_setWindowSize", _wrap_SoSceneManager_setWindowSize, METH_VARARGS, "SoSceneManager_setWindowSize(SoSceneManager self, SbVec2s newsize)"},
	 { "SoSceneManager_getWindowSize", _wrap_SoSceneManager_getWindowSize, METH_O, "SoSceneManager_getWindowSize(SoSceneManager self) -> SbVec2s"},
	 { "SoSceneManager_setSize", _wrap_SoSceneManager_setSize, METH_VARARGS, "SoSceneManager_setSize(SoSceneManager self, SbVec2s newsize)"},
	 { "SoSceneManager_getSize", _wrap_SoSceneManager_getSize, METH_O, "SoSceneManager_getSize(SoSceneManager self) -> SbVec2s"},
	 { "SoSceneManager_setOrigin", _wrap_SoSceneManager_setOrigin, METH_VARARGS, "SoSceneManager_setOrigin(SoSceneManager self, SbVec2s newOrigin)"},
	 { "SoSceneManager_getOrigin", _wrap_SoSceneManager_getOrigin, METH_O, "SoSceneManager_getOrigin(SoSceneManager self) -> SbVec2s"},
	 { "SoSceneManager_setViewportRegion", _wrap_SoSceneManager_setViewportRegion, METH_VARARGS, "SoSceneManager_setViewportRegion(SoSceneManager self, SbViewportRegion newRegion)"},
	 { "SoSceneManager_getViewportRegion", _wrap_SoSceneManager_getViewportRegion, METH_O, "SoSceneManager_getViewportRegion(SoSceneManager self) -> SbViewportRegion"},
	 { "SoSceneManager_setBackgroundColor", _wrap_SoSceneManager_setBackgroundColor, METH_VARARGS, "SoSceneManager_setBackgroundColor(SoSceneManager self, SbColor color)"},
	 { "SoSceneManager_getBackgroundColor", _wrap_SoSceneManager_getBackgroundColor, METH_O, "SoSceneManager_getBackgroundColor(SoSceneManager self) -> SbColor"},
	 { "SoSceneManager_setBackgroundIndex", _wrap_SoSceneManager_setBackgroundIndex, METH_VARARGS, "SoSceneManager_setBackgroundIndex(SoSceneManager self, int const index)"},
	 { "SoSceneManager_getBackgroundIndex", _wrap_SoSceneManager_getBackgroundIndex, METH_O, "SoSceneManager_getBackgroundIndex(SoSceneManager self) -> int"},
	 { "SoSceneManager_setRGBMode", _wrap_SoSceneManager_setRGBMode, METH_VARARGS, "SoSceneManager_setRGBMode(SoSceneManager self, SbBool const onOrOff)"},
	 { "SoSceneManager_isRGBMode", _wrap_SoSceneManager_isRGBMode, METH_O, "SoSceneManager_isRGBMode(SoSceneManager self) -> SbBool"},
	 { "SoSceneManager_activate", _wrap_SoSceneManager_activate, METH_O, "SoSceneManager_activate(SoSceneManager self)"},
	 { "SoSceneManager_deactivate", _wrap_SoSceneManager_deactivate, METH_O, "SoSceneManager_deactivate(SoSceneManager self)"},
	 { "SoSceneManager_isAutoRedraw", _wrap_SoSceneManager_isAutoRedraw, METH_O, "SoSceneManager_isAutoRedraw(SoSceneManager self) -> SbBool"},
	 { "SoSceneManager_setRedrawPriority", _wrap_SoSceneManager_setRedrawPriority, METH_VARARGS, "SoSceneManager_setRedrawPriority(SoSceneManager self, uint32_t const priority)"},
	 { "SoSceneManager_getRedrawPriority", _wrap_SoSceneManager_getRedrawPriority, METH_O, "SoSceneManager_getRedrawPriority(SoSceneManager self) -> uint32_t"},
	 { "SoSceneManager_setAntialiasing", _wrap_SoSceneManager_setAntialiasing, METH_VARARGS, "SoSceneManager_setAntialiasing(SoSceneManager self, SbBool const smoothing, int const numPasses)"},
	 { "SoSceneManager_getAntialiasing", _wrap_SoSceneManager_getAntialiasing, METH_VARARGS, "SoSceneManager_getAntialiasing(SoSceneManager self, SbBool & smoothing, int & numPasses)"},
	 { "SoSceneManager_setGLRenderAction", _wrap_SoSceneManager_setGLRenderAction, METH_VARARGS, "SoSceneManager_setGLRenderAction(SoSceneManager self, SoGLRenderAction action)"},
	 { "SoSceneManager_getGLRenderAction", _wrap_SoSceneManager_getGLRenderAction, METH_O, "SoSceneManager_getGLRenderAction(SoSceneManager self) -> SoGLRenderAction"},
	 { "SoSceneManager_setAudioRenderAction", _wrap_SoSceneManager_setAudioRenderAction, METH_VARARGS, "SoSceneManager_setAudioRenderAction(SoSceneManager self, SoAudioRenderAction action)"},
	 { "SoSceneManager_getAudioRenderAction", _wrap_SoSceneManager_getAudioRenderAction, METH_O, "SoSceneManager_getAudioRenderAction(SoSceneManager self) -> SoAudioRenderAction"},
	 { "SoSceneManager_setHandleEventAction", _wrap_SoSceneManager_setHandleEventAction, METH_VARARGS, "SoSceneManager_setHandleEventAction(SoSceneManager self, SoHandleEventAction hea)"},
	 { "SoSceneManager_getHandleEventAction", _wrap_SoSceneManager_getHandleEventAction, METH_O, "SoSceneManager_getHandleEventAction(SoSceneManager self) -> SoHandleEventAction"},
	 { "SoSceneManager_getDefaultRedrawPriority", _wrap_SoSceneManager_getDefaultRedrawPriority, METH_NOARGS, "SoSceneManager_getDefaultRedrawPriority() -> uint32_t"},
	 { "SoSceneManager_enableRealTimeUpdate", _wrap_SoSceneManager_enableRealTimeUpdate, METH_O, "SoSceneManager_enableRealTimeUpdate(SbBool const flag)"},
	 { "SoSceneManager_isRealTimeUpdateEnabled", _wrap_SoSceneManager_isRealTimeUpdateEnabled, METH_NOARGS, "SoSceneManager_isRealTimeUpdateEnabled() -> SbBool"},
	 { "SoSceneManager_setRenderCallback", _wrap_SoSceneManager_setRenderCallback, METH_VARARGS, "\n"
		"SoSceneManager_setRenderCallback(SoSceneManager self, SoSceneManagerRenderCB * f, void *const userData=None)\n"
		"SoSceneManager_setRenderCallback(SoSceneManager self, PyObject * pyfunc, PyObject * userData=None)\n"
		""},
	 { "SoSceneManager_swigregister", SoSceneManager_swigregister, METH_O, NULL},
	 { "SoSceneManager_swiginit", SoSceneManager_swiginit, METH_VARARGS, NULL},
	 { "new_SbBarrier", _wrap_new_SbBarrier, METH_O, "new_SbBarrier(unsigned int count) -> SbBarrier"},
	 { "delete_SbBarrier", _wrap_delete_SbBarrier, METH_O, "delete_SbBarrier(SbBarrier self)"},
	 { "SbBarrier_enter", _wrap_SbBarrier_enter, METH_O, "SbBarrier_enter(SbBarrier self) -> int"},
	 { "SbBarrier_swigregister", SbBarrier_swigregister, METH_O, NULL},
	 { "SbBarrier_swiginit", SbBarrier_swiginit, METH_VARARGS, NULL},
	 { "new_SbMutex", _wrap_new_SbMutex, METH_NOARGS, "new_SbMutex() -> SbMutex"},
	 { "delete_SbMutex", _wrap_delete_SbMutex, METH_O, "delete_SbMutex(SbMutex self)"},
	 { "SbMutex_lock", _wrap_SbMutex_lock, METH_O, "SbMutex_lock(SbMutex self) -> int"},
	 { "SbMutex_tryLock", _wrap_SbMutex_tryLock, METH_O, "SbMutex_tryLock(SbMutex self) -> SbBool"},
	 { "SbMutex_unlock", _wrap_SbMutex_unlock, METH_O, "SbMutex_unlock(SbMutex self) -> int"},
	 { "SbMutex_swigregister", SbMutex_swigregister, METH_O, NULL},
	 { "SbMutex_swiginit", SbMutex_swiginit, METH_VARARGS, NULL},
	 { "new_SbThreadMutex", _wrap_new_SbThreadMutex, METH_NOARGS, "new_SbThreadMutex() -> SbThreadMutex"},
	 { "delete_SbThreadMutex", _wrap_delete_SbThreadMutex, METH_O, "delete_SbThreadMutex(SbThreadMutex self)"},
	 { "SbThreadMutex_lock", _wrap_SbThreadMutex_lock, METH_O, "SbThreadMutex_lock(SbThreadMutex self) -> int"},
	 { "SbThreadMutex_tryLock", _wrap_SbThreadMutex_tryLock, METH_O, "SbThreadMutex_tryLock(SbThreadMutex self) -> SbBool"},
	 { "SbThreadMutex_unlock", _wrap_SbThreadMutex_unlock, METH_O, "SbThreadMutex_unlock(SbThreadMutex self) -> int"},
	 { "SbThreadMutex_swigregister", SbThreadMutex_swigregister, METH_O, NULL},
	 { "SbThreadMutex_swiginit", SbThreadMutex_swiginit, METH_VARARGS, NULL},
	 { "new_SbThreadAutoLock", _wrap_new_SbThreadAutoLock, METH_VARARGS, "\n"
		"SbThreadAutoLock(SbMutex mutexptr)\n"
		"new_SbThreadAutoLock(SbThreadMutex mutexptr) -> SbThreadAutoLock\n"
		""},
	 { "delete_SbThreadAutoLock", _wrap_delete_SbThreadAutoLock, METH_O, "delete_SbThreadAutoLock(SbThreadAutoLock self)"},
	 { "SbThreadAutoLock_swigregister", SbThreadAutoLock_swigregister, METH_O, NULL},
	 { "SbThreadAutoLock_swiginit", SbThreadAutoLock_swiginit, METH_VARARGS, NULL},
	 { "new_SbCondVar", _wrap_new_SbCondVar, METH_NOARGS, "new_SbCondVar() -> SbCondVar"},
	 { "delete_SbCondVar", _wrap_delete_SbCondVar, METH_O, "delete_SbCondVar(SbCondVar self)"},
	 { "SbCondVar_wait", _wrap_SbCondVar_wait, METH_VARARGS, "SbCondVar_wait(SbCondVar self, SbMutex mutex) -> SbBool"},
	 { "SbCondVar_timedWait", _wrap_SbCondVar_timedWait, METH_VARARGS, "SbCondVar_timedWait(SbCondVar self, SbMutex mutex, SbTime period) -> SbBool"},
	 { "SbCondVar_wakeOne", _wrap_SbCondVar_wakeOne, METH_O, "SbCondVar_wakeOne(SbCondVar self)"},
	 { "SbCondVar_wakeAll", _wrap_SbCondVar_wakeAll, METH_O, "SbCondVar_wakeAll(SbCondVar self)"},
	 { "SbCondVar_swigregister", SbCondVar_swigregister, METH_O, NULL},
	 { "SbCondVar_swiginit", SbCondVar_swiginit, METH_VARARGS, NULL},
	 { "new_SbFifo", _wrap_new_SbFifo, METH_NOARGS, "new_SbFifo() -> SbFifo"},
	 { "delete_SbFifo", _wrap_delete_SbFifo, METH_O, "delete_SbFifo(SbFifo self)"},
	 { "SbFifo_assign", _wrap_SbFifo_assign, METH_VARARGS, "SbFifo_assign(SbFifo self, void * ptr, uint32_t type)"},
	 { "SbFifo_retrieve", _wrap_SbFifo_retrieve, METH_VARARGS, "SbFifo_retrieve(SbFifo self, void *& ptr, uint32_t & type)"},
	 { "SbFifo_tryRetrieve", _wrap_SbFifo_tryRetrieve, METH_VARARGS, "SbFifo_tryRetrieve(SbFifo self, void *& ptr, uint32_t & type) -> SbBool"},
	 { "SbFifo_size", _wrap_SbFifo_size, METH_O, "SbFifo_size(SbFifo self) -> unsigned int"},
	 { "SbFifo_lock", _wrap_SbFifo_lock, METH_O, "SbFifo_lock(SbFifo self)"},
	 { "SbFifo_unlock", _wrap_SbFifo_unlock, METH_O, "SbFifo_unlock(SbFifo self)"},
	 { "SbFifo_peek", _wrap_SbFifo_peek, METH_VARARGS, "SbFifo_peek(SbFifo self, void *& item, uint32_t & type) -> SbBool"},
	 { "SbFifo_contains", _wrap_SbFifo_contains, METH_VARARGS, "SbFifo_contains(SbFifo self, void * item) -> SbBool"},
	 { "SbFifo_reclaim", _wrap_SbFifo_reclaim, METH_VARARGS, "SbFifo_reclaim(SbFifo self, void * item) -> SbBool"},
	 { "SbFifo_swigregister", SbFifo_swigregister, METH_O, NULL},
	 { "SbFifo_swiginit", SbFifo_swiginit, METH_VARARGS, NULL},
	 { "new_SbRWMutex", _wrap_new_SbRWMutex, METH_O, "new_SbRWMutex(SbRWMutex::Precedence policy) -> SbRWMutex"},
	 { "delete_SbRWMutex", _wrap_delete_SbRWMutex, METH_O, "delete_SbRWMutex(SbRWMutex self)"},
	 { "SbRWMutex_writeLock", _wrap_SbRWMutex_writeLock, METH_O, "SbRWMutex_writeLock(SbRWMutex self) -> int"},
	 { "SbRWMutex_tryWriteLock", _wrap_SbRWMutex_tryWriteLock, METH_O, "SbRWMutex_tryWriteLock(SbRWMutex self) -> SbBool"},
	 { "SbRWMutex_writeUnlock", _wrap_SbRWMutex_writeUnlock, METH_O, "SbRWMutex_writeUnlock(SbRWMutex self) -> int"},
	 { "SbRWMutex_readLock", _wrap_SbRWMutex_readLock, METH_O, "SbRWMutex_readLock(SbRWMutex self) -> int"},
	 { "SbRWMutex_tryReadLock", _wrap_SbRWMutex_tryReadLock, METH_O, "SbRWMutex_tryReadLock(SbRWMutex self) -> int"},
	 { "SbRWMutex_readUnlock", _wrap_SbRWMutex_readUnlock, METH_O, "SbRWMutex_readUnlock(SbRWMutex self) -> int"},
	 { "SbRWMutex_swigregister", SbRWMutex_swigregister, METH_O, NULL},
	 { "SbRWMutex_swiginit", SbRWMutex_swiginit, METH_VARARGS, NULL},
	 { "new_SbStorage", _wrap_new_SbStorage, METH_VARARGS, "\n"
		"SbStorage(unsigned int size)\n"
		"new_SbStorage(unsigned int size, cc_storage_f * constr, cc_storage_f * destr) -> SbStorage\n"
		""},
	 { "delete_SbStorage", _wrap_delete_SbStorage, METH_O, "delete_SbStorage(SbStorage self)"},
	 { "SbStorage_get", _wrap_SbStorage_get, METH_O, "SbStorage_get(SbStorage self) -> void *"},
	 { "SbStorage_applyToAll", _wrap_SbStorage_applyToAll, METH_VARARGS, "SbStorage_applyToAll(SbStorage self, SbStorageApplyFunc * func, void * closure)"},
	 { "SbStorage_swigregister", SbStorage_swigregister, METH_O, NULL},
	 { "SbStorage_swiginit", SbStorage_swiginit, METH_VARARGS, NULL},
	 { "SbThread_create", _wrap_SbThread_create, METH_VARARGS, "SbThread_create(void *(*)(void *) func, void * closure) -> SbThread"},
	 { "SbThread_destroy", _wrap_SbThread_destroy, METH_O, "SbThread_destroy(SbThread thread)"},
	 { "SbThread_join", _wrap_SbThread_join, METH_VARARGS, "\n"
		"SbThread_join(void ** retval=None) -> SbBool\n"
		"SbThread_join(SbThread thread, void ** retval=None) -> SbBool\n"
		""},
	 { "SbThread_swigregister", SbThread_swigregister, METH_O, NULL},
	 { "SoVRMLParent_getClassTypeId", _wrap_SoVRMLParent_getClassTypeId, METH_NOARGS, "SoVRMLParent_getClassTypeId() -> SoType"},
	 { "SoVRMLParent_getTypeId", _wrap_SoVRMLParent_getTypeId, METH_O, "SoVRMLParent_getTypeId(SoVRMLParent self) -> SoType"},
	 { "SoVRMLParent_initClass", _wrap_SoVRMLParent_initClass, METH_NOARGS, "SoVRMLParent_initClass()"},
	 { "SoVRMLParent_children_set", _wrap_SoVRMLParent_children_set, METH_VARARGS, "SoVRMLParent_children_set(SoVRMLParent self, SoMFNode children)"},
	 { "SoVRMLParent_children_get", _wrap_SoVRMLParent_children_get, METH_O, "SoVRMLParent_children_get(SoVRMLParent self) -> SoMFNode"},
	 { "SoVRMLParent_affectsState", _wrap_SoVRMLParent_affectsState, METH_O, "SoVRMLParent_affectsState(SoVRMLParent self) -> SbBool"},
	 { "SoVRMLParent_addChild", _wrap_SoVRMLParent_addChild, METH_VARARGS, "SoVRMLParent_addChild(SoVRMLParent self, SoNode child)"},
	 { "SoVRMLParent_insertChild", _wrap_SoVRMLParent_insertChild, METH_VARARGS, "SoVRMLParent_insertChild(SoVRMLParent self, SoNode child, int idx)"},
	 { "SoVRMLParent_getChild", _wrap_SoVRMLParent_getChild, METH_VARARGS, "SoVRMLParent_getChild(SoVRMLParent self, int idx) -> SoNode"},
	 { "SoVRMLParent_findChild", _wrap_SoVRMLParent_findChild, METH_VARARGS, "SoVRMLParent_findChild(SoVRMLParent self, SoNode child) -> int"},
	 { "SoVRMLParent_getNumChildren", _wrap_SoVRMLParent_getNumChildren, METH_O, "SoVRMLParent_getNumChildren(SoVRMLParent self) -> int"},
	 { "SoVRMLParent_removeChild", _wrap_SoVRMLParent_removeChild, METH_VARARGS, "\n"
		"SoVRMLParent_removeChild(SoVRMLParent self, int idx)\n"
		"SoVRMLParent_removeChild(SoVRMLParent self, SoNode child)\n"
		""},
	 { "SoVRMLParent_removeAllChildren", _wrap_SoVRMLParent_removeAllChildren, METH_O, "SoVRMLParent_removeAllChildren(SoVRMLParent self)"},
	 { "SoVRMLParent_replaceChild", _wrap_SoVRMLParent_replaceChild, METH_VARARGS, "\n"
		"SoVRMLParent_replaceChild(SoVRMLParent self, int idx, SoNode child)\n"
		"SoVRMLParent_replaceChild(SoVRMLParent self, SoNode old, SoNode child)\n"
		""},
	 { "SoVRMLParent_getChildren", _wrap_SoVRMLParent_getChildren, METH_O, "SoVRMLParent_getChildren(SoVRMLParent self) -> SoChildList"},
	 { "SoVRMLParent_doAction", _wrap_SoVRMLParent_doAction, METH_VARARGS, "SoVRMLParent_doAction(SoVRMLParent self, SoAction action)"},
	 { "SoVRMLParent_search", _wrap_SoVRMLParent_search, METH_VARARGS, "SoVRMLParent_search(SoVRMLParent self, SoSearchAction action)"},
	 { "SoVRMLParent_write", _wrap_SoVRMLParent_write, METH_VARARGS, "SoVRMLParent_write(SoVRMLParent self, SoWriteAction action)"},
	 { "SoVRMLParent_getPrimitiveCount", _wrap_SoVRMLParent_getPrimitiveCount, METH_VARARGS, "SoVRMLParent_getPrimitiveCount(SoVRMLParent self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLParent_updateChildList", _wrap_SoVRMLParent_updateChildList, METH_VARARGS, "\n"
		"SoVRMLParent_updateChildList(SoNode const *const * nodes, int const numnodes, SoChildList cl)\n"
		"SoVRMLParent_updateChildList(SoNode nodewithsfnode, SoChildList cl)\n"
		""},
	 { "SoVRMLParent_swigregister", SoVRMLParent_swigregister, METH_O, NULL},
	 { "SoVRMLAnchor_getClassTypeId", _wrap_SoVRMLAnchor_getClassTypeId, METH_NOARGS, "SoVRMLAnchor_getClassTypeId() -> SoType"},
	 { "SoVRMLAnchor_getTypeId", _wrap_SoVRMLAnchor_getTypeId, METH_O, "SoVRMLAnchor_getTypeId(SoVRMLAnchor self) -> SoType"},
	 { "SoVRMLAnchor_initClass", _wrap_SoVRMLAnchor_initClass, METH_NOARGS, "SoVRMLAnchor_initClass()"},
	 { "new_SoVRMLAnchor", _wrap_new_SoVRMLAnchor, METH_NOARGS, "new_SoVRMLAnchor() -> SoVRMLAnchor"},
	 { "SoVRMLAnchor_url_set", _wrap_SoVRMLAnchor_url_set, METH_VARARGS, "SoVRMLAnchor_url_set(SoVRMLAnchor self, SoMFString url)"},
	 { "SoVRMLAnchor_url_get", _wrap_SoVRMLAnchor_url_get, METH_O, "SoVRMLAnchor_url_get(SoVRMLAnchor self) -> SoMFString"},
	 { "SoVRMLAnchor_description_set", _wrap_SoVRMLAnchor_description_set, METH_VARARGS, "SoVRMLAnchor_description_set(SoVRMLAnchor self, SoSFString description)"},
	 { "SoVRMLAnchor_description_get", _wrap_SoVRMLAnchor_description_get, METH_O, "SoVRMLAnchor_description_get(SoVRMLAnchor self) -> SoSFString"},
	 { "SoVRMLAnchor_parameter_set", _wrap_SoVRMLAnchor_parameter_set, METH_VARARGS, "SoVRMLAnchor_parameter_set(SoVRMLAnchor self, SoMFString parameter)"},
	 { "SoVRMLAnchor_parameter_get", _wrap_SoVRMLAnchor_parameter_get, METH_O, "SoVRMLAnchor_parameter_get(SoVRMLAnchor self) -> SoMFString"},
	 { "SoVRMLAnchor_bboxCenter_set", _wrap_SoVRMLAnchor_bboxCenter_set, METH_VARARGS, "SoVRMLAnchor_bboxCenter_set(SoVRMLAnchor self, SoSFVec3f bboxCenter)"},
	 { "SoVRMLAnchor_bboxCenter_get", _wrap_SoVRMLAnchor_bboxCenter_get, METH_O, "SoVRMLAnchor_bboxCenter_get(SoVRMLAnchor self) -> SoSFVec3f"},
	 { "SoVRMLAnchor_bboxSize_set", _wrap_SoVRMLAnchor_bboxSize_set, METH_VARARGS, "SoVRMLAnchor_bboxSize_set(SoVRMLAnchor self, SoSFVec3f bboxSize)"},
	 { "SoVRMLAnchor_bboxSize_get", _wrap_SoVRMLAnchor_bboxSize_get, METH_O, "SoVRMLAnchor_bboxSize_get(SoVRMLAnchor self) -> SoSFVec3f"},
	 { "SoVRMLAnchor_setFetchURLCallBack", _wrap_SoVRMLAnchor_setFetchURLCallBack, METH_VARARGS, "SoVRMLAnchor_setFetchURLCallBack(SoVRMLAnchorCB * arg1, void * closure)"},
	 { "SoVRMLAnchor_handleEvent", _wrap_SoVRMLAnchor_handleEvent, METH_VARARGS, "SoVRMLAnchor_handleEvent(SoVRMLAnchor self, SoHandleEventAction action)"},
	 { "SoVRMLAnchor_swigregister", SoVRMLAnchor_swigregister, METH_O, NULL},
	 { "SoVRMLAnchor_swiginit", SoVRMLAnchor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLAppearance_getClassTypeId", _wrap_SoVRMLAppearance_getClassTypeId, METH_NOARGS, "SoVRMLAppearance_getClassTypeId() -> SoType"},
	 { "SoVRMLAppearance_getTypeId", _wrap_SoVRMLAppearance_getTypeId, METH_O, "SoVRMLAppearance_getTypeId(SoVRMLAppearance self) -> SoType"},
	 { "SoVRMLAppearance_initClass", _wrap_SoVRMLAppearance_initClass, METH_NOARGS, "SoVRMLAppearance_initClass()"},
	 { "new_SoVRMLAppearance", _wrap_new_SoVRMLAppearance, METH_NOARGS, "new_SoVRMLAppearance() -> SoVRMLAppearance"},
	 { "SoVRMLAppearance_material_set", _wrap_SoVRMLAppearance_material_set, METH_VARARGS, "SoVRMLAppearance_material_set(SoVRMLAppearance self, SoSFNode material)"},
	 { "SoVRMLAppearance_material_get", _wrap_SoVRMLAppearance_material_get, METH_O, "SoVRMLAppearance_material_get(SoVRMLAppearance self) -> SoSFNode"},
	 { "SoVRMLAppearance_texture_set", _wrap_SoVRMLAppearance_texture_set, METH_VARARGS, "SoVRMLAppearance_texture_set(SoVRMLAppearance self, SoSFNode texture)"},
	 { "SoVRMLAppearance_texture_get", _wrap_SoVRMLAppearance_texture_get, METH_O, "SoVRMLAppearance_texture_get(SoVRMLAppearance self) -> SoSFNode"},
	 { "SoVRMLAppearance_textureTransform_set", _wrap_SoVRMLAppearance_textureTransform_set, METH_VARARGS, "SoVRMLAppearance_textureTransform_set(SoVRMLAppearance self, SoSFNode textureTransform)"},
	 { "SoVRMLAppearance_textureTransform_get", _wrap_SoVRMLAppearance_textureTransform_get, METH_O, "SoVRMLAppearance_textureTransform_get(SoVRMLAppearance self) -> SoSFNode"},
	 { "SoVRMLAppearance_doAction", _wrap_SoVRMLAppearance_doAction, METH_VARARGS, "SoVRMLAppearance_doAction(SoVRMLAppearance self, SoAction action)"},
	 { "SoVRMLAppearance_callback", _wrap_SoVRMLAppearance_callback, METH_VARARGS, "SoVRMLAppearance_callback(SoVRMLAppearance self, SoCallbackAction action)"},
	 { "SoVRMLAppearance_GLRender", _wrap_SoVRMLAppearance_GLRender, METH_VARARGS, "SoVRMLAppearance_GLRender(SoVRMLAppearance self, SoGLRenderAction action)"},
	 { "SoVRMLAppearance_search", _wrap_SoVRMLAppearance_search, METH_VARARGS, "SoVRMLAppearance_search(SoVRMLAppearance self, SoSearchAction action)"},
	 { "SoVRMLAppearance_getChildren", _wrap_SoVRMLAppearance_getChildren, METH_O, "SoVRMLAppearance_getChildren(SoVRMLAppearance self) -> SoChildList"},
	 { "SoVRMLAppearance_notify", _wrap_SoVRMLAppearance_notify, METH_VARARGS, "SoVRMLAppearance_notify(SoVRMLAppearance self, SoNotList list)"},
	 { "SoVRMLAppearance_copyContents", _wrap_SoVRMLAppearance_copyContents, METH_VARARGS, "SoVRMLAppearance_copyContents(SoVRMLAppearance self, SoFieldContainer srcFrom, SbBool copyConn)"},
	 { "SoVRMLAppearance_swigregister", SoVRMLAppearance_swigregister, METH_O, NULL},
	 { "SoVRMLAppearance_swiginit", SoVRMLAppearance_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLAudioClip_getClassTypeId", _wrap_SoVRMLAudioClip_getClassTypeId, METH_NOARGS, "SoVRMLAudioClip_getClassTypeId() -> SoType"},
	 { "SoVRMLAudioClip_getTypeId", _wrap_SoVRMLAudioClip_getTypeId, METH_O, "SoVRMLAudioClip_getTypeId(SoVRMLAudioClip self) -> SoType"},
	 { "SoVRMLAudioClip_initClass", _wrap_SoVRMLAudioClip_initClass, METH_NOARGS, "SoVRMLAudioClip_initClass()"},
	 { "new_SoVRMLAudioClip", _wrap_new_SoVRMLAudioClip, METH_NOARGS, "new_SoVRMLAudioClip() -> SoVRMLAudioClip"},
	 { "SoVRMLAudioClip_description_set", _wrap_SoVRMLAudioClip_description_set, METH_VARARGS, "SoVRMLAudioClip_description_set(SoVRMLAudioClip self, SoSFString description)"},
	 { "SoVRMLAudioClip_description_get", _wrap_SoVRMLAudioClip_description_get, METH_O, "SoVRMLAudioClip_description_get(SoVRMLAudioClip self) -> SoSFString"},
	 { "SoVRMLAudioClip_loop_set", _wrap_SoVRMLAudioClip_loop_set, METH_VARARGS, "SoVRMLAudioClip_loop_set(SoVRMLAudioClip self, SoSFBool loop)"},
	 { "SoVRMLAudioClip_loop_get", _wrap_SoVRMLAudioClip_loop_get, METH_O, "SoVRMLAudioClip_loop_get(SoVRMLAudioClip self) -> SoSFBool"},
	 { "SoVRMLAudioClip_pitch_set", _wrap_SoVRMLAudioClip_pitch_set, METH_VARARGS, "SoVRMLAudioClip_pitch_set(SoVRMLAudioClip self, SoSFFloat pitch)"},
	 { "SoVRMLAudioClip_pitch_get", _wrap_SoVRMLAudioClip_pitch_get, METH_O, "SoVRMLAudioClip_pitch_get(SoVRMLAudioClip self) -> SoSFFloat"},
	 { "SoVRMLAudioClip_startTime_set", _wrap_SoVRMLAudioClip_startTime_set, METH_VARARGS, "SoVRMLAudioClip_startTime_set(SoVRMLAudioClip self, SoSFTime startTime)"},
	 { "SoVRMLAudioClip_startTime_get", _wrap_SoVRMLAudioClip_startTime_get, METH_O, "SoVRMLAudioClip_startTime_get(SoVRMLAudioClip self) -> SoSFTime"},
	 { "SoVRMLAudioClip_stopTime_set", _wrap_SoVRMLAudioClip_stopTime_set, METH_VARARGS, "SoVRMLAudioClip_stopTime_set(SoVRMLAudioClip self, SoSFTime stopTime)"},
	 { "SoVRMLAudioClip_stopTime_get", _wrap_SoVRMLAudioClip_stopTime_get, METH_O, "SoVRMLAudioClip_stopTime_get(SoVRMLAudioClip self) -> SoSFTime"},
	 { "SoVRMLAudioClip_url_set", _wrap_SoVRMLAudioClip_url_set, METH_VARARGS, "SoVRMLAudioClip_url_set(SoVRMLAudioClip self, SoMFString url)"},
	 { "SoVRMLAudioClip_url_get", _wrap_SoVRMLAudioClip_url_get, METH_O, "SoVRMLAudioClip_url_get(SoVRMLAudioClip self) -> SoMFString"},
	 { "SoVRMLAudioClip_setSubdirectories", _wrap_SoVRMLAudioClip_setSubdirectories, METH_O, "SoVRMLAudioClip_setSubdirectories(SbList< SbString > const & subdirectories)"},
	 { "SoVRMLAudioClip_getSubdirectories", _wrap_SoVRMLAudioClip_getSubdirectories, METH_NOARGS, "SoVRMLAudioClip_getSubdirectories() -> SbStringList"},
	 { "SoVRMLAudioClip_setDefaultPauseBetweenTracks", _wrap_SoVRMLAudioClip_setDefaultPauseBetweenTracks, METH_O, "SoVRMLAudioClip_setDefaultPauseBetweenTracks(SbTime pause)"},
	 { "SoVRMLAudioClip_getDefaultPauseBetweenTracks", _wrap_SoVRMLAudioClip_getDefaultPauseBetweenTracks, METH_NOARGS, "SoVRMLAudioClip_getDefaultPauseBetweenTracks() -> SbTime"},
	 { "SoVRMLAudioClip_setDefaultIntroPause", _wrap_SoVRMLAudioClip_setDefaultIntroPause, METH_O, "SoVRMLAudioClip_setDefaultIntroPause(SbTime pause)"},
	 { "SoVRMLAudioClip_getDefaultIntroPause", _wrap_SoVRMLAudioClip_getDefaultIntroPause, METH_NOARGS, "SoVRMLAudioClip_getDefaultIntroPause() -> SbTime"},
	 { "SoVRMLAudioClip_setDefaultSampleRate", _wrap_SoVRMLAudioClip_setDefaultSampleRate, METH_O, "SoVRMLAudioClip_setDefaultSampleRate(int samplerate)"},
	 { "SoVRMLAudioClip_getDefaultSampleRate", _wrap_SoVRMLAudioClip_getDefaultSampleRate, METH_NOARGS, "SoVRMLAudioClip_getDefaultSampleRate() -> int"},
	 { "SoVRMLAudioClip_setDefaultTimerInterval", _wrap_SoVRMLAudioClip_setDefaultTimerInterval, METH_O, "SoVRMLAudioClip_setDefaultTimerInterval(SbTime interval)"},
	 { "SoVRMLAudioClip_getDefaultTimerInterval", _wrap_SoVRMLAudioClip_getDefaultTimerInterval, METH_NOARGS, "SoVRMLAudioClip_getDefaultTimerInterval() -> SbTime"},
	 { "SoVRMLAudioClip_getSampleRate", _wrap_SoVRMLAudioClip_getSampleRate, METH_O, "SoVRMLAudioClip_getSampleRate(SoVRMLAudioClip self) -> int"},
	 { "SoVRMLAudioClip_open", _wrap_SoVRMLAudioClip_open, METH_VARARGS, "SoVRMLAudioClip_open(SoVRMLAudioClip self, SbStringList url) -> void *"},
	 { "SoVRMLAudioClip_read", _wrap_SoVRMLAudioClip_read, METH_VARARGS, "SoVRMLAudioClip_read(SoVRMLAudioClip self, void * datasource, void * buffer, int numframes, int & channels) -> size_t"},
	 { "SoVRMLAudioClip_seek", _wrap_SoVRMLAudioClip_seek, METH_VARARGS, "SoVRMLAudioClip_seek(SoVRMLAudioClip self, void * datasource, long offset, int whence) -> int"},
	 { "SoVRMLAudioClip_tell", _wrap_SoVRMLAudioClip_tell, METH_VARARGS, "SoVRMLAudioClip_tell(SoVRMLAudioClip self, void * datasource) -> long"},
	 { "SoVRMLAudioClip_close", _wrap_SoVRMLAudioClip_close, METH_VARARGS, "SoVRMLAudioClip_close(SoVRMLAudioClip self, void * datasource) -> int"},
	 { "SoVRMLAudioClip_setCallbacks", _wrap_SoVRMLAudioClip_setCallbacks, METH_VARARGS, "SoVRMLAudioClip_setCallbacks(SoVRMLAudioClip self, SoVRMLAudioClip::open_func * opencb, SoVRMLAudioClip::read_func * readcb, SoVRMLAudioClip::seek_func * seekcb, SoVRMLAudioClip::tell_func * tellcb, SoVRMLAudioClip::close_func * closecb, void * userdataptr)"},
	 { "SoVRMLAudioClip_swigregister", SoVRMLAudioClip_swigregister, METH_O, NULL},
	 { "SoVRMLAudioClip_swiginit", SoVRMLAudioClip_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLBackground_getClassTypeId", _wrap_SoVRMLBackground_getClassTypeId, METH_NOARGS, "SoVRMLBackground_getClassTypeId() -> SoType"},
	 { "SoVRMLBackground_getTypeId", _wrap_SoVRMLBackground_getTypeId, METH_O, "SoVRMLBackground_getTypeId(SoVRMLBackground self) -> SoType"},
	 { "SoVRMLBackground_initClass", _wrap_SoVRMLBackground_initClass, METH_NOARGS, "SoVRMLBackground_initClass()"},
	 { "new_SoVRMLBackground", _wrap_new_SoVRMLBackground, METH_NOARGS, "new_SoVRMLBackground() -> SoVRMLBackground"},
	 { "SoVRMLBackground_groundColor_set", _wrap_SoVRMLBackground_groundColor_set, METH_VARARGS, "SoVRMLBackground_groundColor_set(SoVRMLBackground self, SoMFColor groundColor)"},
	 { "SoVRMLBackground_groundColor_get", _wrap_SoVRMLBackground_groundColor_get, METH_O, "SoVRMLBackground_groundColor_get(SoVRMLBackground self) -> SoMFColor"},
	 { "SoVRMLBackground_groundAngle_set", _wrap_SoVRMLBackground_groundAngle_set, METH_VARARGS, "SoVRMLBackground_groundAngle_set(SoVRMLBackground self, SoMFFloat groundAngle)"},
	 { "SoVRMLBackground_groundAngle_get", _wrap_SoVRMLBackground_groundAngle_get, METH_O, "SoVRMLBackground_groundAngle_get(SoVRMLBackground self) -> SoMFFloat"},
	 { "SoVRMLBackground_skyColor_set", _wrap_SoVRMLBackground_skyColor_set, METH_VARARGS, "SoVRMLBackground_skyColor_set(SoVRMLBackground self, SoMFColor skyColor)"},
	 { "SoVRMLBackground_skyColor_get", _wrap_SoVRMLBackground_skyColor_get, METH_O, "SoVRMLBackground_skyColor_get(SoVRMLBackground self) -> SoMFColor"},
	 { "SoVRMLBackground_skyAngle_set", _wrap_SoVRMLBackground_skyAngle_set, METH_VARARGS, "SoVRMLBackground_skyAngle_set(SoVRMLBackground self, SoMFFloat skyAngle)"},
	 { "SoVRMLBackground_skyAngle_get", _wrap_SoVRMLBackground_skyAngle_get, METH_O, "SoVRMLBackground_skyAngle_get(SoVRMLBackground self) -> SoMFFloat"},
	 { "SoVRMLBackground_backUrl_set", _wrap_SoVRMLBackground_backUrl_set, METH_VARARGS, "SoVRMLBackground_backUrl_set(SoVRMLBackground self, SoMFString backUrl)"},
	 { "SoVRMLBackground_backUrl_get", _wrap_SoVRMLBackground_backUrl_get, METH_O, "SoVRMLBackground_backUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_bottomUrl_set", _wrap_SoVRMLBackground_bottomUrl_set, METH_VARARGS, "SoVRMLBackground_bottomUrl_set(SoVRMLBackground self, SoMFString bottomUrl)"},
	 { "SoVRMLBackground_bottomUrl_get", _wrap_SoVRMLBackground_bottomUrl_get, METH_O, "SoVRMLBackground_bottomUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_frontUrl_set", _wrap_SoVRMLBackground_frontUrl_set, METH_VARARGS, "SoVRMLBackground_frontUrl_set(SoVRMLBackground self, SoMFString frontUrl)"},
	 { "SoVRMLBackground_frontUrl_get", _wrap_SoVRMLBackground_frontUrl_get, METH_O, "SoVRMLBackground_frontUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_leftUrl_set", _wrap_SoVRMLBackground_leftUrl_set, METH_VARARGS, "SoVRMLBackground_leftUrl_set(SoVRMLBackground self, SoMFString leftUrl)"},
	 { "SoVRMLBackground_leftUrl_get", _wrap_SoVRMLBackground_leftUrl_get, METH_O, "SoVRMLBackground_leftUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_rightUrl_set", _wrap_SoVRMLBackground_rightUrl_set, METH_VARARGS, "SoVRMLBackground_rightUrl_set(SoVRMLBackground self, SoMFString rightUrl)"},
	 { "SoVRMLBackground_rightUrl_get", _wrap_SoVRMLBackground_rightUrl_get, METH_O, "SoVRMLBackground_rightUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_topUrl_set", _wrap_SoVRMLBackground_topUrl_set, METH_VARARGS, "SoVRMLBackground_topUrl_set(SoVRMLBackground self, SoMFString topUrl)"},
	 { "SoVRMLBackground_topUrl_get", _wrap_SoVRMLBackground_topUrl_get, METH_O, "SoVRMLBackground_topUrl_get(SoVRMLBackground self) -> SoMFString"},
	 { "SoVRMLBackground_GLRender", _wrap_SoVRMLBackground_GLRender, METH_VARARGS, "SoVRMLBackground_GLRender(SoVRMLBackground self, SoGLRenderAction action)"},
	 { "SoVRMLBackground_swigregister", SoVRMLBackground_swigregister, METH_O, NULL},
	 { "SoVRMLBackground_swiginit", SoVRMLBackground_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLBillboard_getClassTypeId", _wrap_SoVRMLBillboard_getClassTypeId, METH_NOARGS, "SoVRMLBillboard_getClassTypeId() -> SoType"},
	 { "SoVRMLBillboard_getTypeId", _wrap_SoVRMLBillboard_getTypeId, METH_O, "SoVRMLBillboard_getTypeId(SoVRMLBillboard self) -> SoType"},
	 { "SoVRMLBillboard_initClass", _wrap_SoVRMLBillboard_initClass, METH_NOARGS, "SoVRMLBillboard_initClass()"},
	 { "new_SoVRMLBillboard", _wrap_new_SoVRMLBillboard, METH_VARARGS, "\n"
		"SoVRMLBillboard()\n"
		"new_SoVRMLBillboard(int numchildren) -> SoVRMLBillboard\n"
		""},
	 { "SoVRMLBillboard_axisOfRotation_set", _wrap_SoVRMLBillboard_axisOfRotation_set, METH_VARARGS, "SoVRMLBillboard_axisOfRotation_set(SoVRMLBillboard self, SoSFVec3f axisOfRotation)"},
	 { "SoVRMLBillboard_axisOfRotation_get", _wrap_SoVRMLBillboard_axisOfRotation_get, METH_O, "SoVRMLBillboard_axisOfRotation_get(SoVRMLBillboard self) -> SoSFVec3f"},
	 { "SoVRMLBillboard_bboxCenter_set", _wrap_SoVRMLBillboard_bboxCenter_set, METH_VARARGS, "SoVRMLBillboard_bboxCenter_set(SoVRMLBillboard self, SoSFVec3f bboxCenter)"},
	 { "SoVRMLBillboard_bboxCenter_get", _wrap_SoVRMLBillboard_bboxCenter_get, METH_O, "SoVRMLBillboard_bboxCenter_get(SoVRMLBillboard self) -> SoSFVec3f"},
	 { "SoVRMLBillboard_bboxSize_set", _wrap_SoVRMLBillboard_bboxSize_set, METH_VARARGS, "SoVRMLBillboard_bboxSize_set(SoVRMLBillboard self, SoSFVec3f bboxSize)"},
	 { "SoVRMLBillboard_bboxSize_get", _wrap_SoVRMLBillboard_bboxSize_get, METH_O, "SoVRMLBillboard_bboxSize_get(SoVRMLBillboard self) -> SoSFVec3f"},
	 { "SoVRMLBillboard_doAction", _wrap_SoVRMLBillboard_doAction, METH_VARARGS, "SoVRMLBillboard_doAction(SoVRMLBillboard self, SoAction action)"},
	 { "SoVRMLBillboard_callback", _wrap_SoVRMLBillboard_callback, METH_VARARGS, "SoVRMLBillboard_callback(SoVRMLBillboard self, SoCallbackAction action)"},
	 { "SoVRMLBillboard_GLRender", _wrap_SoVRMLBillboard_GLRender, METH_VARARGS, "SoVRMLBillboard_GLRender(SoVRMLBillboard self, SoGLRenderAction action)"},
	 { "SoVRMLBillboard_getBoundingBox", _wrap_SoVRMLBillboard_getBoundingBox, METH_VARARGS, "SoVRMLBillboard_getBoundingBox(SoVRMLBillboard self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLBillboard_getMatrix", _wrap_SoVRMLBillboard_getMatrix, METH_VARARGS, "SoVRMLBillboard_getMatrix(SoVRMLBillboard self, SoGetMatrixAction action)"},
	 { "SoVRMLBillboard_pick", _wrap_SoVRMLBillboard_pick, METH_VARARGS, "SoVRMLBillboard_pick(SoVRMLBillboard self, SoPickAction action)"},
	 { "SoVRMLBillboard_search", _wrap_SoVRMLBillboard_search, METH_VARARGS, "SoVRMLBillboard_search(SoVRMLBillboard self, SoSearchAction action)"},
	 { "SoVRMLBillboard_GLRenderBelowPath", _wrap_SoVRMLBillboard_GLRenderBelowPath, METH_VARARGS, "SoVRMLBillboard_GLRenderBelowPath(SoVRMLBillboard self, SoGLRenderAction action)"},
	 { "SoVRMLBillboard_GLRenderInPath", _wrap_SoVRMLBillboard_GLRenderInPath, METH_VARARGS, "SoVRMLBillboard_GLRenderInPath(SoVRMLBillboard self, SoGLRenderAction action)"},
	 { "SoVRMLBillboard_GLRenderOffPath", _wrap_SoVRMLBillboard_GLRenderOffPath, METH_VARARGS, "SoVRMLBillboard_GLRenderOffPath(SoVRMLBillboard self, SoGLRenderAction action)"},
	 { "SoVRMLBillboard_notify", _wrap_SoVRMLBillboard_notify, METH_VARARGS, "SoVRMLBillboard_notify(SoVRMLBillboard self, SoNotList list)"},
	 { "SoVRMLBillboard_swigregister", SoVRMLBillboard_swigregister, METH_O, NULL},
	 { "SoVRMLBillboard_swiginit", SoVRMLBillboard_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLGeometry_getClassTypeId", _wrap_SoVRMLGeometry_getClassTypeId, METH_NOARGS, "SoVRMLGeometry_getClassTypeId() -> SoType"},
	 { "SoVRMLGeometry_getTypeId", _wrap_SoVRMLGeometry_getTypeId, METH_O, "SoVRMLGeometry_getTypeId(SoVRMLGeometry self) -> SoType"},
	 { "SoVRMLGeometry_initClass", _wrap_SoVRMLGeometry_initClass, METH_NOARGS, "SoVRMLGeometry_initClass()"},
	 { "SoVRMLGeometry_search", _wrap_SoVRMLGeometry_search, METH_VARARGS, "SoVRMLGeometry_search(SoVRMLGeometry self, SoSearchAction action)"},
	 { "SoVRMLGeometry_copyContents", _wrap_SoVRMLGeometry_copyContents, METH_VARARGS, "SoVRMLGeometry_copyContents(SoVRMLGeometry self, SoFieldContainer srcFrom, SbBool copyConn)"},
	 { "SoVRMLGeometry_swigregister", SoVRMLGeometry_swigregister, METH_O, NULL},
	 { "SoVRMLBox_getClassTypeId", _wrap_SoVRMLBox_getClassTypeId, METH_NOARGS, "SoVRMLBox_getClassTypeId() -> SoType"},
	 { "SoVRMLBox_getTypeId", _wrap_SoVRMLBox_getTypeId, METH_O, "SoVRMLBox_getTypeId(SoVRMLBox self) -> SoType"},
	 { "SoVRMLBox_initClass", _wrap_SoVRMLBox_initClass, METH_NOARGS, "SoVRMLBox_initClass()"},
	 { "new_SoVRMLBox", _wrap_new_SoVRMLBox, METH_NOARGS, "new_SoVRMLBox() -> SoVRMLBox"},
	 { "SoVRMLBox_size_set", _wrap_SoVRMLBox_size_set, METH_VARARGS, "SoVRMLBox_size_set(SoVRMLBox self, SoSFVec3f size)"},
	 { "SoVRMLBox_size_get", _wrap_SoVRMLBox_size_get, METH_O, "SoVRMLBox_size_get(SoVRMLBox self) -> SoSFVec3f"},
	 { "SoVRMLBox_GLRender", _wrap_SoVRMLBox_GLRender, METH_VARARGS, "SoVRMLBox_GLRender(SoVRMLBox self, SoGLRenderAction action)"},
	 { "SoVRMLBox_rayPick", _wrap_SoVRMLBox_rayPick, METH_VARARGS, "SoVRMLBox_rayPick(SoVRMLBox self, SoRayPickAction action)"},
	 { "SoVRMLBox_getPrimitiveCount", _wrap_SoVRMLBox_getPrimitiveCount, METH_VARARGS, "SoVRMLBox_getPrimitiveCount(SoVRMLBox self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLBox_swigregister", SoVRMLBox_swigregister, METH_O, NULL},
	 { "SoVRMLBox_swiginit", SoVRMLBox_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLGroup_getClassTypeId", _wrap_SoVRMLGroup_getClassTypeId, METH_NOARGS, "SoVRMLGroup_getClassTypeId() -> SoType"},
	 { "SoVRMLGroup_getTypeId", _wrap_SoVRMLGroup_getTypeId, METH_O, "SoVRMLGroup_getTypeId(SoVRMLGroup self) -> SoType"},
	 { "SoVRMLGroup_initClass", _wrap_SoVRMLGroup_initClass, METH_NOARGS, "SoVRMLGroup_initClass()"},
	 { "new_SoVRMLGroup", _wrap_new_SoVRMLGroup, METH_VARARGS, "\n"
		"SoVRMLGroup()\n"
		"new_SoVRMLGroup(int numChildren) -> SoVRMLGroup\n"
		""},
	 { "SoVRMLGroup_renderCaching_set", _wrap_SoVRMLGroup_renderCaching_set, METH_VARARGS, "SoVRMLGroup_renderCaching_set(SoVRMLGroup self, SoSFEnum renderCaching)"},
	 { "SoVRMLGroup_renderCaching_get", _wrap_SoVRMLGroup_renderCaching_get, METH_O, "SoVRMLGroup_renderCaching_get(SoVRMLGroup self) -> SoSFEnum"},
	 { "SoVRMLGroup_boundingBoxCaching_set", _wrap_SoVRMLGroup_boundingBoxCaching_set, METH_VARARGS, "SoVRMLGroup_boundingBoxCaching_set(SoVRMLGroup self, SoSFEnum boundingBoxCaching)"},
	 { "SoVRMLGroup_boundingBoxCaching_get", _wrap_SoVRMLGroup_boundingBoxCaching_get, METH_O, "SoVRMLGroup_boundingBoxCaching_get(SoVRMLGroup self) -> SoSFEnum"},
	 { "SoVRMLGroup_renderCulling_set", _wrap_SoVRMLGroup_renderCulling_set, METH_VARARGS, "SoVRMLGroup_renderCulling_set(SoVRMLGroup self, SoSFEnum renderCulling)"},
	 { "SoVRMLGroup_renderCulling_get", _wrap_SoVRMLGroup_renderCulling_get, METH_O, "SoVRMLGroup_renderCulling_get(SoVRMLGroup self) -> SoSFEnum"},
	 { "SoVRMLGroup_pickCulling_set", _wrap_SoVRMLGroup_pickCulling_set, METH_VARARGS, "SoVRMLGroup_pickCulling_set(SoVRMLGroup self, SoSFEnum pickCulling)"},
	 { "SoVRMLGroup_pickCulling_get", _wrap_SoVRMLGroup_pickCulling_get, METH_O, "SoVRMLGroup_pickCulling_get(SoVRMLGroup self) -> SoSFEnum"},
	 { "SoVRMLGroup_bboxCenter_set", _wrap_SoVRMLGroup_bboxCenter_set, METH_VARARGS, "SoVRMLGroup_bboxCenter_set(SoVRMLGroup self, SoSFVec3f bboxCenter)"},
	 { "SoVRMLGroup_bboxCenter_get", _wrap_SoVRMLGroup_bboxCenter_get, METH_O, "SoVRMLGroup_bboxCenter_get(SoVRMLGroup self) -> SoSFVec3f"},
	 { "SoVRMLGroup_bboxSize_set", _wrap_SoVRMLGroup_bboxSize_set, METH_VARARGS, "SoVRMLGroup_bboxSize_set(SoVRMLGroup self, SoSFVec3f bboxSize)"},
	 { "SoVRMLGroup_bboxSize_get", _wrap_SoVRMLGroup_bboxSize_get, METH_O, "SoVRMLGroup_bboxSize_get(SoVRMLGroup self) -> SoSFVec3f"},
	 { "SoVRMLGroup_setNumRenderCaches", _wrap_SoVRMLGroup_setNumRenderCaches, METH_O, "SoVRMLGroup_setNumRenderCaches(int num)"},
	 { "SoVRMLGroup_getNumRenderCaches", _wrap_SoVRMLGroup_getNumRenderCaches, METH_NOARGS, "SoVRMLGroup_getNumRenderCaches() -> int"},
	 { "SoVRMLGroup_doAction", _wrap_SoVRMLGroup_doAction, METH_VARARGS, "SoVRMLGroup_doAction(SoVRMLGroup self, SoAction action)"},
	 { "SoVRMLGroup_callback", _wrap_SoVRMLGroup_callback, METH_VARARGS, "SoVRMLGroup_callback(SoVRMLGroup self, SoCallbackAction action)"},
	 { "SoVRMLGroup_GLRender", _wrap_SoVRMLGroup_GLRender, METH_VARARGS, "SoVRMLGroup_GLRender(SoVRMLGroup self, SoGLRenderAction action)"},
	 { "SoVRMLGroup_getBoundingBox", _wrap_SoVRMLGroup_getBoundingBox, METH_VARARGS, "SoVRMLGroup_getBoundingBox(SoVRMLGroup self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLGroup_getMatrix", _wrap_SoVRMLGroup_getMatrix, METH_VARARGS, "SoVRMLGroup_getMatrix(SoVRMLGroup self, SoGetMatrixAction action)"},
	 { "SoVRMLGroup_rayPick", _wrap_SoVRMLGroup_rayPick, METH_VARARGS, "SoVRMLGroup_rayPick(SoVRMLGroup self, SoRayPickAction action)"},
	 { "SoVRMLGroup_search", _wrap_SoVRMLGroup_search, METH_VARARGS, "SoVRMLGroup_search(SoVRMLGroup self, SoSearchAction action)"},
	 { "SoVRMLGroup_write", _wrap_SoVRMLGroup_write, METH_VARARGS, "SoVRMLGroup_write(SoVRMLGroup self, SoWriteAction action)"},
	 { "SoVRMLGroup_getPrimitiveCount", _wrap_SoVRMLGroup_getPrimitiveCount, METH_VARARGS, "SoVRMLGroup_getPrimitiveCount(SoVRMLGroup self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLGroup_audioRender", _wrap_SoVRMLGroup_audioRender, METH_VARARGS, "SoVRMLGroup_audioRender(SoVRMLGroup self, SoAudioRenderAction action)"},
	 { "SoVRMLGroup_GLRenderBelowPath", _wrap_SoVRMLGroup_GLRenderBelowPath, METH_VARARGS, "SoVRMLGroup_GLRenderBelowPath(SoVRMLGroup self, SoGLRenderAction action)"},
	 { "SoVRMLGroup_GLRenderInPath", _wrap_SoVRMLGroup_GLRenderInPath, METH_VARARGS, "SoVRMLGroup_GLRenderInPath(SoVRMLGroup self, SoGLRenderAction action)"},
	 { "SoVRMLGroup_GLRenderOffPath", _wrap_SoVRMLGroup_GLRenderOffPath, METH_VARARGS, "SoVRMLGroup_GLRenderOffPath(SoVRMLGroup self, SoGLRenderAction action)"},
	 { "SoVRMLGroup_notify", _wrap_SoVRMLGroup_notify, METH_VARARGS, "SoVRMLGroup_notify(SoVRMLGroup self, SoNotList list)"},
	 { "SoVRMLGroup_swigregister", SoVRMLGroup_swigregister, METH_O, NULL},
	 { "SoVRMLGroup_swiginit", SoVRMLGroup_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLCollision_getClassTypeId", _wrap_SoVRMLCollision_getClassTypeId, METH_NOARGS, "SoVRMLCollision_getClassTypeId() -> SoType"},
	 { "SoVRMLCollision_getTypeId", _wrap_SoVRMLCollision_getTypeId, METH_O, "SoVRMLCollision_getTypeId(SoVRMLCollision self) -> SoType"},
	 { "SoVRMLCollision_initClass", _wrap_SoVRMLCollision_initClass, METH_NOARGS, "SoVRMLCollision_initClass()"},
	 { "new_SoVRMLCollision", _wrap_new_SoVRMLCollision, METH_VARARGS, "\n"
		"SoVRMLCollision()\n"
		"new_SoVRMLCollision(int numchildren) -> SoVRMLCollision\n"
		""},
	 { "SoVRMLCollision_collide_set", _wrap_SoVRMLCollision_collide_set, METH_VARARGS, "SoVRMLCollision_collide_set(SoVRMLCollision self, SoSFBool collide)"},
	 { "SoVRMLCollision_collide_get", _wrap_SoVRMLCollision_collide_get, METH_O, "SoVRMLCollision_collide_get(SoVRMLCollision self) -> SoSFBool"},
	 { "SoVRMLCollision_proxy_set", _wrap_SoVRMLCollision_proxy_set, METH_VARARGS, "SoVRMLCollision_proxy_set(SoVRMLCollision self, SoSFNode proxy)"},
	 { "SoVRMLCollision_proxy_get", _wrap_SoVRMLCollision_proxy_get, METH_O, "SoVRMLCollision_proxy_get(SoVRMLCollision self) -> SoSFNode"},
	 { "SoVRMLCollision_collideTime_set", _wrap_SoVRMLCollision_collideTime_set, METH_VARARGS, "SoVRMLCollision_collideTime_set(SoVRMLCollision self, SoSFTime collideTime)"},
	 { "SoVRMLCollision_collideTime_get", _wrap_SoVRMLCollision_collideTime_get, METH_O, "SoVRMLCollision_collideTime_get(SoVRMLCollision self) -> SoSFTime"},
	 { "SoVRMLCollision_GLRender", _wrap_SoVRMLCollision_GLRender, METH_VARARGS, "SoVRMLCollision_GLRender(SoVRMLCollision self, SoGLRenderAction action)"},
	 { "SoVRMLCollision_notify", _wrap_SoVRMLCollision_notify, METH_VARARGS, "SoVRMLCollision_notify(SoVRMLCollision self, SoNotList list)"},
	 { "SoVRMLCollision_swigregister", SoVRMLCollision_swigregister, METH_O, NULL},
	 { "SoVRMLCollision_swiginit", SoVRMLCollision_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLColor_getClassTypeId", _wrap_SoVRMLColor_getClassTypeId, METH_NOARGS, "SoVRMLColor_getClassTypeId() -> SoType"},
	 { "SoVRMLColor_getTypeId", _wrap_SoVRMLColor_getTypeId, METH_O, "SoVRMLColor_getTypeId(SoVRMLColor self) -> SoType"},
	 { "SoVRMLColor_initClass", _wrap_SoVRMLColor_initClass, METH_NOARGS, "SoVRMLColor_initClass()"},
	 { "new_SoVRMLColor", _wrap_new_SoVRMLColor, METH_NOARGS, "new_SoVRMLColor() -> SoVRMLColor"},
	 { "SoVRMLColor_color_set", _wrap_SoVRMLColor_color_set, METH_VARARGS, "SoVRMLColor_color_set(SoVRMLColor self, SoMFColor color)"},
	 { "SoVRMLColor_color_get", _wrap_SoVRMLColor_color_get, METH_O, "SoVRMLColor_color_get(SoVRMLColor self) -> SoMFColor"},
	 { "SoVRMLColor_doAction", _wrap_SoVRMLColor_doAction, METH_VARARGS, "SoVRMLColor_doAction(SoVRMLColor self, SoAction action)"},
	 { "SoVRMLColor_GLRender", _wrap_SoVRMLColor_GLRender, METH_VARARGS, "SoVRMLColor_GLRender(SoVRMLColor self, SoGLRenderAction action)"},
	 { "SoVRMLColor_callback", _wrap_SoVRMLColor_callback, METH_VARARGS, "SoVRMLColor_callback(SoVRMLColor self, SoCallbackAction action)"},
	 { "SoVRMLColor_swigregister", SoVRMLColor_swigregister, METH_O, NULL},
	 { "SoVRMLColor_swiginit", SoVRMLColor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLInterpolator_getClassTypeId", _wrap_SoVRMLInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLInterpolator_getTypeId", _wrap_SoVRMLInterpolator_getTypeId, METH_O, "SoVRMLInterpolator_getTypeId(SoVRMLInterpolator self) -> SoType"},
	 { "SoVRMLInterpolator_getOutputData", _wrap_SoVRMLInterpolator_getOutputData, METH_O, "SoVRMLInterpolator_getOutputData(SoVRMLInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLInterpolator_key_set", _wrap_SoVRMLInterpolator_key_set, METH_VARARGS, "SoVRMLInterpolator_key_set(SoVRMLInterpolator self, SoMFFloat key)"},
	 { "SoVRMLInterpolator_key_get", _wrap_SoVRMLInterpolator_key_get, METH_O, "SoVRMLInterpolator_key_get(SoVRMLInterpolator self) -> SoMFFloat"},
	 { "SoVRMLInterpolator_set_fraction_set", _wrap_SoVRMLInterpolator_set_fraction_set, METH_VARARGS, "SoVRMLInterpolator_set_fraction_set(SoVRMLInterpolator self, SoSFFloat set_fraction)"},
	 { "SoVRMLInterpolator_set_fraction_get", _wrap_SoVRMLInterpolator_set_fraction_get, METH_O, "SoVRMLInterpolator_set_fraction_get(SoVRMLInterpolator self) -> SoSFFloat"},
	 { "SoVRMLInterpolator_initClass", _wrap_SoVRMLInterpolator_initClass, METH_NOARGS, "SoVRMLInterpolator_initClass()"},
	 { "SoVRMLInterpolator_swigregister", SoVRMLInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLColorInterpolator_getClassTypeId", _wrap_SoVRMLColorInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLColorInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLColorInterpolator_getTypeId", _wrap_SoVRMLColorInterpolator_getTypeId, METH_O, "SoVRMLColorInterpolator_getTypeId(SoVRMLColorInterpolator self) -> SoType"},
	 { "SoVRMLColorInterpolator_getOutputData", _wrap_SoVRMLColorInterpolator_getOutputData, METH_O, "SoVRMLColorInterpolator_getOutputData(SoVRMLColorInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLColorInterpolator_createInstance", _wrap_SoVRMLColorInterpolator_createInstance, METH_NOARGS, "SoVRMLColorInterpolator_createInstance() -> void *"},
	 { "SoVRMLColorInterpolator_initClass", _wrap_SoVRMLColorInterpolator_initClass, METH_NOARGS, "SoVRMLColorInterpolator_initClass()"},
	 { "new_SoVRMLColorInterpolator", _wrap_new_SoVRMLColorInterpolator, METH_NOARGS, "new_SoVRMLColorInterpolator() -> SoVRMLColorInterpolator"},
	 { "SoVRMLColorInterpolator_keyValue_set", _wrap_SoVRMLColorInterpolator_keyValue_set, METH_VARARGS, "SoVRMLColorInterpolator_keyValue_set(SoVRMLColorInterpolator self, SoMFColor keyValue)"},
	 { "SoVRMLColorInterpolator_keyValue_get", _wrap_SoVRMLColorInterpolator_keyValue_get, METH_O, "SoVRMLColorInterpolator_keyValue_get(SoVRMLColorInterpolator self) -> SoMFColor"},
	 { "SoVRMLColorInterpolator_value_changed_set", _wrap_SoVRMLColorInterpolator_value_changed_set, METH_VARARGS, "SoVRMLColorInterpolator_value_changed_set(SoVRMLColorInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLColorInterpolator_value_changed_get", _wrap_SoVRMLColorInterpolator_value_changed_get, METH_O, "SoVRMLColorInterpolator_value_changed_get(SoVRMLColorInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLColorInterpolator_swigregister", SoVRMLColorInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLColorInterpolator_swiginit", SoVRMLColorInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLCone_getClassTypeId", _wrap_SoVRMLCone_getClassTypeId, METH_NOARGS, "SoVRMLCone_getClassTypeId() -> SoType"},
	 { "SoVRMLCone_getTypeId", _wrap_SoVRMLCone_getTypeId, METH_O, "SoVRMLCone_getTypeId(SoVRMLCone self) -> SoType"},
	 { "SoVRMLCone_initClass", _wrap_SoVRMLCone_initClass, METH_NOARGS, "SoVRMLCone_initClass()"},
	 { "new_SoVRMLCone", _wrap_new_SoVRMLCone, METH_NOARGS, "new_SoVRMLCone() -> SoVRMLCone"},
	 { "SoVRMLCone_bottomRadius_set", _wrap_SoVRMLCone_bottomRadius_set, METH_VARARGS, "SoVRMLCone_bottomRadius_set(SoVRMLCone self, SoSFFloat bottomRadius)"},
	 { "SoVRMLCone_bottomRadius_get", _wrap_SoVRMLCone_bottomRadius_get, METH_O, "SoVRMLCone_bottomRadius_get(SoVRMLCone self) -> SoSFFloat"},
	 { "SoVRMLCone_height_set", _wrap_SoVRMLCone_height_set, METH_VARARGS, "SoVRMLCone_height_set(SoVRMLCone self, SoSFFloat height)"},
	 { "SoVRMLCone_height_get", _wrap_SoVRMLCone_height_get, METH_O, "SoVRMLCone_height_get(SoVRMLCone self) -> SoSFFloat"},
	 { "SoVRMLCone_side_set", _wrap_SoVRMLCone_side_set, METH_VARARGS, "SoVRMLCone_side_set(SoVRMLCone self, SoSFBool side)"},
	 { "SoVRMLCone_side_get", _wrap_SoVRMLCone_side_get, METH_O, "SoVRMLCone_side_get(SoVRMLCone self) -> SoSFBool"},
	 { "SoVRMLCone_bottom_set", _wrap_SoVRMLCone_bottom_set, METH_VARARGS, "SoVRMLCone_bottom_set(SoVRMLCone self, SoSFBool bottom)"},
	 { "SoVRMLCone_bottom_get", _wrap_SoVRMLCone_bottom_get, METH_O, "SoVRMLCone_bottom_get(SoVRMLCone self) -> SoSFBool"},
	 { "SoVRMLCone_GLRender", _wrap_SoVRMLCone_GLRender, METH_VARARGS, "SoVRMLCone_GLRender(SoVRMLCone self, SoGLRenderAction action)"},
	 { "SoVRMLCone_rayPick", _wrap_SoVRMLCone_rayPick, METH_VARARGS, "SoVRMLCone_rayPick(SoVRMLCone self, SoRayPickAction action)"},
	 { "SoVRMLCone_getPrimitiveCount", _wrap_SoVRMLCone_getPrimitiveCount, METH_VARARGS, "SoVRMLCone_getPrimitiveCount(SoVRMLCone self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLCone_swigregister", SoVRMLCone_swigregister, METH_O, NULL},
	 { "SoVRMLCone_swiginit", SoVRMLCone_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLCoordinate_getClassTypeId", _wrap_SoVRMLCoordinate_getClassTypeId, METH_NOARGS, "SoVRMLCoordinate_getClassTypeId() -> SoType"},
	 { "SoVRMLCoordinate_getTypeId", _wrap_SoVRMLCoordinate_getTypeId, METH_O, "SoVRMLCoordinate_getTypeId(SoVRMLCoordinate self) -> SoType"},
	 { "SoVRMLCoordinate_initClass", _wrap_SoVRMLCoordinate_initClass, METH_NOARGS, "SoVRMLCoordinate_initClass()"},
	 { "new_SoVRMLCoordinate", _wrap_new_SoVRMLCoordinate, METH_NOARGS, "new_SoVRMLCoordinate() -> SoVRMLCoordinate"},
	 { "SoVRMLCoordinate_point_set", _wrap_SoVRMLCoordinate_point_set, METH_VARARGS, "SoVRMLCoordinate_point_set(SoVRMLCoordinate self, SoMFVec3f point)"},
	 { "SoVRMLCoordinate_point_get", _wrap_SoVRMLCoordinate_point_get, METH_O, "SoVRMLCoordinate_point_get(SoVRMLCoordinate self) -> SoMFVec3f"},
	 { "SoVRMLCoordinate_doAction", _wrap_SoVRMLCoordinate_doAction, METH_VARARGS, "SoVRMLCoordinate_doAction(SoVRMLCoordinate self, SoAction action)"},
	 { "SoVRMLCoordinate_GLRender", _wrap_SoVRMLCoordinate_GLRender, METH_VARARGS, "SoVRMLCoordinate_GLRender(SoVRMLCoordinate self, SoGLRenderAction action)"},
	 { "SoVRMLCoordinate_getBoundingBox", _wrap_SoVRMLCoordinate_getBoundingBox, METH_VARARGS, "SoVRMLCoordinate_getBoundingBox(SoVRMLCoordinate self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLCoordinate_callback", _wrap_SoVRMLCoordinate_callback, METH_VARARGS, "SoVRMLCoordinate_callback(SoVRMLCoordinate self, SoCallbackAction action)"},
	 { "SoVRMLCoordinate_pick", _wrap_SoVRMLCoordinate_pick, METH_VARARGS, "SoVRMLCoordinate_pick(SoVRMLCoordinate self, SoPickAction action)"},
	 { "SoVRMLCoordinate_swigregister", SoVRMLCoordinate_swigregister, METH_O, NULL},
	 { "SoVRMLCoordinate_swiginit", SoVRMLCoordinate_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLCoordinateInterpolator_getClassTypeId", _wrap_SoVRMLCoordinateInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLCoordinateInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLCoordinateInterpolator_getTypeId", _wrap_SoVRMLCoordinateInterpolator_getTypeId, METH_O, "SoVRMLCoordinateInterpolator_getTypeId(SoVRMLCoordinateInterpolator self) -> SoType"},
	 { "SoVRMLCoordinateInterpolator_getOutputData", _wrap_SoVRMLCoordinateInterpolator_getOutputData, METH_O, "SoVRMLCoordinateInterpolator_getOutputData(SoVRMLCoordinateInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLCoordinateInterpolator_createInstance", _wrap_SoVRMLCoordinateInterpolator_createInstance, METH_NOARGS, "SoVRMLCoordinateInterpolator_createInstance() -> void *"},
	 { "SoVRMLCoordinateInterpolator_initClass", _wrap_SoVRMLCoordinateInterpolator_initClass, METH_NOARGS, "SoVRMLCoordinateInterpolator_initClass()"},
	 { "new_SoVRMLCoordinateInterpolator", _wrap_new_SoVRMLCoordinateInterpolator, METH_NOARGS, "new_SoVRMLCoordinateInterpolator() -> SoVRMLCoordinateInterpolator"},
	 { "SoVRMLCoordinateInterpolator_keyValue_set", _wrap_SoVRMLCoordinateInterpolator_keyValue_set, METH_VARARGS, "SoVRMLCoordinateInterpolator_keyValue_set(SoVRMLCoordinateInterpolator self, SoMFVec3f keyValue)"},
	 { "SoVRMLCoordinateInterpolator_keyValue_get", _wrap_SoVRMLCoordinateInterpolator_keyValue_get, METH_O, "SoVRMLCoordinateInterpolator_keyValue_get(SoVRMLCoordinateInterpolator self) -> SoMFVec3f"},
	 { "SoVRMLCoordinateInterpolator_value_changed_set", _wrap_SoVRMLCoordinateInterpolator_value_changed_set, METH_VARARGS, "SoVRMLCoordinateInterpolator_value_changed_set(SoVRMLCoordinateInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLCoordinateInterpolator_value_changed_get", _wrap_SoVRMLCoordinateInterpolator_value_changed_get, METH_O, "SoVRMLCoordinateInterpolator_value_changed_get(SoVRMLCoordinateInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLCoordinateInterpolator_swigregister", SoVRMLCoordinateInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLCoordinateInterpolator_swiginit", SoVRMLCoordinateInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLCylinder_getClassTypeId", _wrap_SoVRMLCylinder_getClassTypeId, METH_NOARGS, "SoVRMLCylinder_getClassTypeId() -> SoType"},
	 { "SoVRMLCylinder_getTypeId", _wrap_SoVRMLCylinder_getTypeId, METH_O, "SoVRMLCylinder_getTypeId(SoVRMLCylinder self) -> SoType"},
	 { "SoVRMLCylinder_initClass", _wrap_SoVRMLCylinder_initClass, METH_NOARGS, "SoVRMLCylinder_initClass()"},
	 { "new_SoVRMLCylinder", _wrap_new_SoVRMLCylinder, METH_NOARGS, "new_SoVRMLCylinder() -> SoVRMLCylinder"},
	 { "SoVRMLCylinder_radius_set", _wrap_SoVRMLCylinder_radius_set, METH_VARARGS, "SoVRMLCylinder_radius_set(SoVRMLCylinder self, SoSFFloat radius)"},
	 { "SoVRMLCylinder_radius_get", _wrap_SoVRMLCylinder_radius_get, METH_O, "SoVRMLCylinder_radius_get(SoVRMLCylinder self) -> SoSFFloat"},
	 { "SoVRMLCylinder_height_set", _wrap_SoVRMLCylinder_height_set, METH_VARARGS, "SoVRMLCylinder_height_set(SoVRMLCylinder self, SoSFFloat height)"},
	 { "SoVRMLCylinder_height_get", _wrap_SoVRMLCylinder_height_get, METH_O, "SoVRMLCylinder_height_get(SoVRMLCylinder self) -> SoSFFloat"},
	 { "SoVRMLCylinder_side_set", _wrap_SoVRMLCylinder_side_set, METH_VARARGS, "SoVRMLCylinder_side_set(SoVRMLCylinder self, SoSFBool side)"},
	 { "SoVRMLCylinder_side_get", _wrap_SoVRMLCylinder_side_get, METH_O, "SoVRMLCylinder_side_get(SoVRMLCylinder self) -> SoSFBool"},
	 { "SoVRMLCylinder_top_set", _wrap_SoVRMLCylinder_top_set, METH_VARARGS, "SoVRMLCylinder_top_set(SoVRMLCylinder self, SoSFBool top)"},
	 { "SoVRMLCylinder_top_get", _wrap_SoVRMLCylinder_top_get, METH_O, "SoVRMLCylinder_top_get(SoVRMLCylinder self) -> SoSFBool"},
	 { "SoVRMLCylinder_bottom_set", _wrap_SoVRMLCylinder_bottom_set, METH_VARARGS, "SoVRMLCylinder_bottom_set(SoVRMLCylinder self, SoSFBool bottom)"},
	 { "SoVRMLCylinder_bottom_get", _wrap_SoVRMLCylinder_bottom_get, METH_O, "SoVRMLCylinder_bottom_get(SoVRMLCylinder self) -> SoSFBool"},
	 { "SoVRMLCylinder_GLRender", _wrap_SoVRMLCylinder_GLRender, METH_VARARGS, "SoVRMLCylinder_GLRender(SoVRMLCylinder self, SoGLRenderAction action)"},
	 { "SoVRMLCylinder_rayPick", _wrap_SoVRMLCylinder_rayPick, METH_VARARGS, "SoVRMLCylinder_rayPick(SoVRMLCylinder self, SoRayPickAction action)"},
	 { "SoVRMLCylinder_getPrimitiveCount", _wrap_SoVRMLCylinder_getPrimitiveCount, METH_VARARGS, "SoVRMLCylinder_getPrimitiveCount(SoVRMLCylinder self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLCylinder_swigregister", SoVRMLCylinder_swigregister, METH_O, NULL},
	 { "SoVRMLCylinder_swiginit", SoVRMLCylinder_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSensor_getClassTypeId", _wrap_SoVRMLSensor_getClassTypeId, METH_NOARGS, "SoVRMLSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLSensor_getTypeId", _wrap_SoVRMLSensor_getTypeId, METH_O, "SoVRMLSensor_getTypeId(SoVRMLSensor self) -> SoType"},
	 { "SoVRMLSensor_isActive_set", _wrap_SoVRMLSensor_isActive_set, METH_VARARGS, "SoVRMLSensor_isActive_set(SoVRMLSensor self, SoSFBool isActive)"},
	 { "SoVRMLSensor_isActive_get", _wrap_SoVRMLSensor_isActive_get, METH_O, "SoVRMLSensor_isActive_get(SoVRMLSensor self) -> SoSFBool"},
	 { "SoVRMLSensor_enabled_set", _wrap_SoVRMLSensor_enabled_set, METH_VARARGS, "SoVRMLSensor_enabled_set(SoVRMLSensor self, SoSFBool enabled)"},
	 { "SoVRMLSensor_enabled_get", _wrap_SoVRMLSensor_enabled_get, METH_O, "SoVRMLSensor_enabled_get(SoVRMLSensor self) -> SoSFBool"},
	 { "SoVRMLSensor_initClass", _wrap_SoVRMLSensor_initClass, METH_NOARGS, "SoVRMLSensor_initClass()"},
	 { "SoVRMLSensor_swigregister", SoVRMLSensor_swigregister, METH_O, NULL},
	 { "SoVRMLDragSensor_getClassTypeId", _wrap_SoVRMLDragSensor_getClassTypeId, METH_NOARGS, "SoVRMLDragSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLDragSensor_getTypeId", _wrap_SoVRMLDragSensor_getTypeId, METH_O, "SoVRMLDragSensor_getTypeId(SoVRMLDragSensor self) -> SoType"},
	 { "SoVRMLDragSensor_trackPoint_changed_set", _wrap_SoVRMLDragSensor_trackPoint_changed_set, METH_VARARGS, "SoVRMLDragSensor_trackPoint_changed_set(SoVRMLDragSensor self, SoSFVec3f trackPoint_changed)"},
	 { "SoVRMLDragSensor_trackPoint_changed_get", _wrap_SoVRMLDragSensor_trackPoint_changed_get, METH_O, "SoVRMLDragSensor_trackPoint_changed_get(SoVRMLDragSensor self) -> SoSFVec3f"},
	 { "SoVRMLDragSensor_autoOffset_set", _wrap_SoVRMLDragSensor_autoOffset_set, METH_VARARGS, "SoVRMLDragSensor_autoOffset_set(SoVRMLDragSensor self, SoSFBool autoOffset)"},
	 { "SoVRMLDragSensor_autoOffset_get", _wrap_SoVRMLDragSensor_autoOffset_get, METH_O, "SoVRMLDragSensor_autoOffset_get(SoVRMLDragSensor self) -> SoSFBool"},
	 { "SoVRMLDragSensor_handleEvent", _wrap_SoVRMLDragSensor_handleEvent, METH_VARARGS, "SoVRMLDragSensor_handleEvent(SoVRMLDragSensor self, SoHandleEventAction action)"},
	 { "SoVRMLDragSensor_initClass", _wrap_SoVRMLDragSensor_initClass, METH_NOARGS, "SoVRMLDragSensor_initClass()"},
	 { "SoVRMLDragSensor_swigregister", SoVRMLDragSensor_swigregister, METH_O, NULL},
	 { "SoVRMLCylinderSensor_getClassTypeId", _wrap_SoVRMLCylinderSensor_getClassTypeId, METH_NOARGS, "SoVRMLCylinderSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLCylinderSensor_getTypeId", _wrap_SoVRMLCylinderSensor_getTypeId, METH_O, "SoVRMLCylinderSensor_getTypeId(SoVRMLCylinderSensor self) -> SoType"},
	 { "SoVRMLCylinderSensor_initClass", _wrap_SoVRMLCylinderSensor_initClass, METH_NOARGS, "SoVRMLCylinderSensor_initClass()"},
	 { "new_SoVRMLCylinderSensor", _wrap_new_SoVRMLCylinderSensor, METH_NOARGS, "new_SoVRMLCylinderSensor() -> SoVRMLCylinderSensor"},
	 { "SoVRMLCylinderSensor_diskAngle_set", _wrap_SoVRMLCylinderSensor_diskAngle_set, METH_VARARGS, "SoVRMLCylinderSensor_diskAngle_set(SoVRMLCylinderSensor self, SoSFFloat diskAngle)"},
	 { "SoVRMLCylinderSensor_diskAngle_get", _wrap_SoVRMLCylinderSensor_diskAngle_get, METH_O, "SoVRMLCylinderSensor_diskAngle_get(SoVRMLCylinderSensor self) -> SoSFFloat"},
	 { "SoVRMLCylinderSensor_maxAngle_set", _wrap_SoVRMLCylinderSensor_maxAngle_set, METH_VARARGS, "SoVRMLCylinderSensor_maxAngle_set(SoVRMLCylinderSensor self, SoSFFloat maxAngle)"},
	 { "SoVRMLCylinderSensor_maxAngle_get", _wrap_SoVRMLCylinderSensor_maxAngle_get, METH_O, "SoVRMLCylinderSensor_maxAngle_get(SoVRMLCylinderSensor self) -> SoSFFloat"},
	 { "SoVRMLCylinderSensor_minAngle_set", _wrap_SoVRMLCylinderSensor_minAngle_set, METH_VARARGS, "SoVRMLCylinderSensor_minAngle_set(SoVRMLCylinderSensor self, SoSFFloat minAngle)"},
	 { "SoVRMLCylinderSensor_minAngle_get", _wrap_SoVRMLCylinderSensor_minAngle_get, METH_O, "SoVRMLCylinderSensor_minAngle_get(SoVRMLCylinderSensor self) -> SoSFFloat"},
	 { "SoVRMLCylinderSensor_offset_set", _wrap_SoVRMLCylinderSensor_offset_set, METH_VARARGS, "SoVRMLCylinderSensor_offset_set(SoVRMLCylinderSensor self, SoSFFloat offset)"},
	 { "SoVRMLCylinderSensor_offset_get", _wrap_SoVRMLCylinderSensor_offset_get, METH_O, "SoVRMLCylinderSensor_offset_get(SoVRMLCylinderSensor self) -> SoSFFloat"},
	 { "SoVRMLCylinderSensor_rotation_changed_set", _wrap_SoVRMLCylinderSensor_rotation_changed_set, METH_VARARGS, "SoVRMLCylinderSensor_rotation_changed_set(SoVRMLCylinderSensor self, SoSFRotation rotation_changed)"},
	 { "SoVRMLCylinderSensor_rotation_changed_get", _wrap_SoVRMLCylinderSensor_rotation_changed_get, METH_O, "SoVRMLCylinderSensor_rotation_changed_get(SoVRMLCylinderSensor self) -> SoSFRotation"},
	 { "SoVRMLCylinderSensor_swigregister", SoVRMLCylinderSensor_swigregister, METH_O, NULL},
	 { "SoVRMLCylinderSensor_swiginit", SoVRMLCylinderSensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLLight_getClassTypeId", _wrap_SoVRMLLight_getClassTypeId, METH_NOARGS, "SoVRMLLight_getClassTypeId() -> SoType"},
	 { "SoVRMLLight_getTypeId", _wrap_SoVRMLLight_getTypeId, METH_O, "SoVRMLLight_getTypeId(SoVRMLLight self) -> SoType"},
	 { "SoVRMLLight_initClass", _wrap_SoVRMLLight_initClass, METH_NOARGS, "SoVRMLLight_initClass()"},
	 { "SoVRMLLight_on_set", _wrap_SoVRMLLight_on_set, METH_VARARGS, "SoVRMLLight_on_set(SoVRMLLight self, SoSFBool on)"},
	 { "SoVRMLLight_on_get", _wrap_SoVRMLLight_on_get, METH_O, "SoVRMLLight_on_get(SoVRMLLight self) -> SoSFBool"},
	 { "SoVRMLLight_intensity_set", _wrap_SoVRMLLight_intensity_set, METH_VARARGS, "SoVRMLLight_intensity_set(SoVRMLLight self, SoSFFloat intensity)"},
	 { "SoVRMLLight_intensity_get", _wrap_SoVRMLLight_intensity_get, METH_O, "SoVRMLLight_intensity_get(SoVRMLLight self) -> SoSFFloat"},
	 { "SoVRMLLight_color_set", _wrap_SoVRMLLight_color_set, METH_VARARGS, "SoVRMLLight_color_set(SoVRMLLight self, SoSFColor color)"},
	 { "SoVRMLLight_color_get", _wrap_SoVRMLLight_color_get, METH_O, "SoVRMLLight_color_get(SoVRMLLight self) -> SoSFColor"},
	 { "SoVRMLLight_ambientIntensity_set", _wrap_SoVRMLLight_ambientIntensity_set, METH_VARARGS, "SoVRMLLight_ambientIntensity_set(SoVRMLLight self, SoSFFloat ambientIntensity)"},
	 { "SoVRMLLight_ambientIntensity_get", _wrap_SoVRMLLight_ambientIntensity_get, METH_O, "SoVRMLLight_ambientIntensity_get(SoVRMLLight self) -> SoSFFloat"},
	 { "SoVRMLLight_GLRender", _wrap_SoVRMLLight_GLRender, METH_VARARGS, "SoVRMLLight_GLRender(SoVRMLLight self, SoGLRenderAction action)"},
	 { "SoVRMLLight_swigregister", SoVRMLLight_swigregister, METH_O, NULL},
	 { "SoVRMLDirectionalLight_getClassTypeId", _wrap_SoVRMLDirectionalLight_getClassTypeId, METH_NOARGS, "SoVRMLDirectionalLight_getClassTypeId() -> SoType"},
	 { "SoVRMLDirectionalLight_getTypeId", _wrap_SoVRMLDirectionalLight_getTypeId, METH_O, "SoVRMLDirectionalLight_getTypeId(SoVRMLDirectionalLight self) -> SoType"},
	 { "SoVRMLDirectionalLight_initClass", _wrap_SoVRMLDirectionalLight_initClass, METH_NOARGS, "SoVRMLDirectionalLight_initClass()"},
	 { "new_SoVRMLDirectionalLight", _wrap_new_SoVRMLDirectionalLight, METH_NOARGS, "new_SoVRMLDirectionalLight() -> SoVRMLDirectionalLight"},
	 { "SoVRMLDirectionalLight_direction_set", _wrap_SoVRMLDirectionalLight_direction_set, METH_VARARGS, "SoVRMLDirectionalLight_direction_set(SoVRMLDirectionalLight self, SoSFVec3f direction)"},
	 { "SoVRMLDirectionalLight_direction_get", _wrap_SoVRMLDirectionalLight_direction_get, METH_O, "SoVRMLDirectionalLight_direction_get(SoVRMLDirectionalLight self) -> SoSFVec3f"},
	 { "SoVRMLDirectionalLight_GLRender", _wrap_SoVRMLDirectionalLight_GLRender, METH_VARARGS, "SoVRMLDirectionalLight_GLRender(SoVRMLDirectionalLight self, SoGLRenderAction action)"},
	 { "SoVRMLDirectionalLight_swigregister", SoVRMLDirectionalLight_swigregister, METH_O, NULL},
	 { "SoVRMLDirectionalLight_swiginit", SoVRMLDirectionalLight_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLElevationGrid_getClassTypeId", _wrap_SoVRMLElevationGrid_getClassTypeId, METH_NOARGS, "SoVRMLElevationGrid_getClassTypeId() -> SoType"},
	 { "SoVRMLElevationGrid_getTypeId", _wrap_SoVRMLElevationGrid_getTypeId, METH_O, "SoVRMLElevationGrid_getTypeId(SoVRMLElevationGrid self) -> SoType"},
	 { "SoVRMLElevationGrid_initClass", _wrap_SoVRMLElevationGrid_initClass, METH_NOARGS, "SoVRMLElevationGrid_initClass()"},
	 { "new_SoVRMLElevationGrid", _wrap_new_SoVRMLElevationGrid, METH_NOARGS, "new_SoVRMLElevationGrid() -> SoVRMLElevationGrid"},
	 { "SoVRMLElevationGrid_ccw_set", _wrap_SoVRMLElevationGrid_ccw_set, METH_VARARGS, "SoVRMLElevationGrid_ccw_set(SoVRMLElevationGrid self, SoSFBool ccw)"},
	 { "SoVRMLElevationGrid_ccw_get", _wrap_SoVRMLElevationGrid_ccw_get, METH_O, "SoVRMLElevationGrid_ccw_get(SoVRMLElevationGrid self) -> SoSFBool"},
	 { "SoVRMLElevationGrid_solid_set", _wrap_SoVRMLElevationGrid_solid_set, METH_VARARGS, "SoVRMLElevationGrid_solid_set(SoVRMLElevationGrid self, SoSFBool solid)"},
	 { "SoVRMLElevationGrid_solid_get", _wrap_SoVRMLElevationGrid_solid_get, METH_O, "SoVRMLElevationGrid_solid_get(SoVRMLElevationGrid self) -> SoSFBool"},
	 { "SoVRMLElevationGrid_creaseAngle_set", _wrap_SoVRMLElevationGrid_creaseAngle_set, METH_VARARGS, "SoVRMLElevationGrid_creaseAngle_set(SoVRMLElevationGrid self, SoSFFloat creaseAngle)"},
	 { "SoVRMLElevationGrid_creaseAngle_get", _wrap_SoVRMLElevationGrid_creaseAngle_get, METH_O, "SoVRMLElevationGrid_creaseAngle_get(SoVRMLElevationGrid self) -> SoSFFloat"},
	 { "SoVRMLElevationGrid_zDimension_set", _wrap_SoVRMLElevationGrid_zDimension_set, METH_VARARGS, "SoVRMLElevationGrid_zDimension_set(SoVRMLElevationGrid self, SoSFInt32 zDimension)"},
	 { "SoVRMLElevationGrid_zDimension_get", _wrap_SoVRMLElevationGrid_zDimension_get, METH_O, "SoVRMLElevationGrid_zDimension_get(SoVRMLElevationGrid self) -> SoSFInt32"},
	 { "SoVRMLElevationGrid_xDimension_set", _wrap_SoVRMLElevationGrid_xDimension_set, METH_VARARGS, "SoVRMLElevationGrid_xDimension_set(SoVRMLElevationGrid self, SoSFInt32 xDimension)"},
	 { "SoVRMLElevationGrid_xDimension_get", _wrap_SoVRMLElevationGrid_xDimension_get, METH_O, "SoVRMLElevationGrid_xDimension_get(SoVRMLElevationGrid self) -> SoSFInt32"},
	 { "SoVRMLElevationGrid_zSpacing_set", _wrap_SoVRMLElevationGrid_zSpacing_set, METH_VARARGS, "SoVRMLElevationGrid_zSpacing_set(SoVRMLElevationGrid self, SoSFFloat zSpacing)"},
	 { "SoVRMLElevationGrid_zSpacing_get", _wrap_SoVRMLElevationGrid_zSpacing_get, METH_O, "SoVRMLElevationGrid_zSpacing_get(SoVRMLElevationGrid self) -> SoSFFloat"},
	 { "SoVRMLElevationGrid_xSpacing_set", _wrap_SoVRMLElevationGrid_xSpacing_set, METH_VARARGS, "SoVRMLElevationGrid_xSpacing_set(SoVRMLElevationGrid self, SoSFFloat xSpacing)"},
	 { "SoVRMLElevationGrid_xSpacing_get", _wrap_SoVRMLElevationGrid_xSpacing_get, METH_O, "SoVRMLElevationGrid_xSpacing_get(SoVRMLElevationGrid self) -> SoSFFloat"},
	 { "SoVRMLElevationGrid_height_set", _wrap_SoVRMLElevationGrid_height_set, METH_VARARGS, "SoVRMLElevationGrid_height_set(SoVRMLElevationGrid self, SoMFFloat height)"},
	 { "SoVRMLElevationGrid_height_get", _wrap_SoVRMLElevationGrid_height_get, METH_O, "SoVRMLElevationGrid_height_get(SoVRMLElevationGrid self) -> SoMFFloat"},
	 { "SoVRMLElevationGrid_texCoord_set", _wrap_SoVRMLElevationGrid_texCoord_set, METH_VARARGS, "SoVRMLElevationGrid_texCoord_set(SoVRMLElevationGrid self, SoSFNode texCoord)"},
	 { "SoVRMLElevationGrid_texCoord_get", _wrap_SoVRMLElevationGrid_texCoord_get, METH_O, "SoVRMLElevationGrid_texCoord_get(SoVRMLElevationGrid self) -> SoSFNode"},
	 { "SoVRMLElevationGrid_normal_set", _wrap_SoVRMLElevationGrid_normal_set, METH_VARARGS, "SoVRMLElevationGrid_normal_set(SoVRMLElevationGrid self, SoSFNode normal)"},
	 { "SoVRMLElevationGrid_normal_get", _wrap_SoVRMLElevationGrid_normal_get, METH_O, "SoVRMLElevationGrid_normal_get(SoVRMLElevationGrid self) -> SoSFNode"},
	 { "SoVRMLElevationGrid_color_set", _wrap_SoVRMLElevationGrid_color_set, METH_VARARGS, "SoVRMLElevationGrid_color_set(SoVRMLElevationGrid self, SoSFNode color)"},
	 { "SoVRMLElevationGrid_color_get", _wrap_SoVRMLElevationGrid_color_get, METH_O, "SoVRMLElevationGrid_color_get(SoVRMLElevationGrid self) -> SoSFNode"},
	 { "SoVRMLElevationGrid_colorPerVertex_set", _wrap_SoVRMLElevationGrid_colorPerVertex_set, METH_VARARGS, "SoVRMLElevationGrid_colorPerVertex_set(SoVRMLElevationGrid self, SoSFBool colorPerVertex)"},
	 { "SoVRMLElevationGrid_colorPerVertex_get", _wrap_SoVRMLElevationGrid_colorPerVertex_get, METH_O, "SoVRMLElevationGrid_colorPerVertex_get(SoVRMLElevationGrid self) -> SoSFBool"},
	 { "SoVRMLElevationGrid_normalPerVertex_set", _wrap_SoVRMLElevationGrid_normalPerVertex_set, METH_VARARGS, "SoVRMLElevationGrid_normalPerVertex_set(SoVRMLElevationGrid self, SoSFBool normalPerVertex)"},
	 { "SoVRMLElevationGrid_normalPerVertex_get", _wrap_SoVRMLElevationGrid_normalPerVertex_get, METH_O, "SoVRMLElevationGrid_normalPerVertex_get(SoVRMLElevationGrid self) -> SoSFBool"},
	 { "SoVRMLElevationGrid_GLRender", _wrap_SoVRMLElevationGrid_GLRender, METH_VARARGS, "SoVRMLElevationGrid_GLRender(SoVRMLElevationGrid self, SoGLRenderAction action)"},
	 { "SoVRMLElevationGrid_rayPick", _wrap_SoVRMLElevationGrid_rayPick, METH_VARARGS, "SoVRMLElevationGrid_rayPick(SoVRMLElevationGrid self, SoRayPickAction action)"},
	 { "SoVRMLElevationGrid_getPrimitiveCount", _wrap_SoVRMLElevationGrid_getPrimitiveCount, METH_VARARGS, "SoVRMLElevationGrid_getPrimitiveCount(SoVRMLElevationGrid self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLElevationGrid_swigregister", SoVRMLElevationGrid_swigregister, METH_O, NULL},
	 { "SoVRMLElevationGrid_swiginit", SoVRMLElevationGrid_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLExtrusion_getClassTypeId", _wrap_SoVRMLExtrusion_getClassTypeId, METH_NOARGS, "SoVRMLExtrusion_getClassTypeId() -> SoType"},
	 { "SoVRMLExtrusion_getTypeId", _wrap_SoVRMLExtrusion_getTypeId, METH_O, "SoVRMLExtrusion_getTypeId(SoVRMLExtrusion self) -> SoType"},
	 { "SoVRMLExtrusion_initClass", _wrap_SoVRMLExtrusion_initClass, METH_NOARGS, "SoVRMLExtrusion_initClass()"},
	 { "new_SoVRMLExtrusion", _wrap_new_SoVRMLExtrusion, METH_NOARGS, "new_SoVRMLExtrusion() -> SoVRMLExtrusion"},
	 { "SoVRMLExtrusion_beginCap_set", _wrap_SoVRMLExtrusion_beginCap_set, METH_VARARGS, "SoVRMLExtrusion_beginCap_set(SoVRMLExtrusion self, SoSFBool beginCap)"},
	 { "SoVRMLExtrusion_beginCap_get", _wrap_SoVRMLExtrusion_beginCap_get, METH_O, "SoVRMLExtrusion_beginCap_get(SoVRMLExtrusion self) -> SoSFBool"},
	 { "SoVRMLExtrusion_ccw_set", _wrap_SoVRMLExtrusion_ccw_set, METH_VARARGS, "SoVRMLExtrusion_ccw_set(SoVRMLExtrusion self, SoSFBool ccw)"},
	 { "SoVRMLExtrusion_ccw_get", _wrap_SoVRMLExtrusion_ccw_get, METH_O, "SoVRMLExtrusion_ccw_get(SoVRMLExtrusion self) -> SoSFBool"},
	 { "SoVRMLExtrusion_convex_set", _wrap_SoVRMLExtrusion_convex_set, METH_VARARGS, "SoVRMLExtrusion_convex_set(SoVRMLExtrusion self, SoSFBool convex)"},
	 { "SoVRMLExtrusion_convex_get", _wrap_SoVRMLExtrusion_convex_get, METH_O, "SoVRMLExtrusion_convex_get(SoVRMLExtrusion self) -> SoSFBool"},
	 { "SoVRMLExtrusion_creaseAngle_set", _wrap_SoVRMLExtrusion_creaseAngle_set, METH_VARARGS, "SoVRMLExtrusion_creaseAngle_set(SoVRMLExtrusion self, SoSFFloat creaseAngle)"},
	 { "SoVRMLExtrusion_creaseAngle_get", _wrap_SoVRMLExtrusion_creaseAngle_get, METH_O, "SoVRMLExtrusion_creaseAngle_get(SoVRMLExtrusion self) -> SoSFFloat"},
	 { "SoVRMLExtrusion_crossSection_set", _wrap_SoVRMLExtrusion_crossSection_set, METH_VARARGS, "SoVRMLExtrusion_crossSection_set(SoVRMLExtrusion self, SoMFVec2f crossSection)"},
	 { "SoVRMLExtrusion_crossSection_get", _wrap_SoVRMLExtrusion_crossSection_get, METH_O, "SoVRMLExtrusion_crossSection_get(SoVRMLExtrusion self) -> SoMFVec2f"},
	 { "SoVRMLExtrusion_endCap_set", _wrap_SoVRMLExtrusion_endCap_set, METH_VARARGS, "SoVRMLExtrusion_endCap_set(SoVRMLExtrusion self, SoSFBool endCap)"},
	 { "SoVRMLExtrusion_endCap_get", _wrap_SoVRMLExtrusion_endCap_get, METH_O, "SoVRMLExtrusion_endCap_get(SoVRMLExtrusion self) -> SoSFBool"},
	 { "SoVRMLExtrusion_orientation_set", _wrap_SoVRMLExtrusion_orientation_set, METH_VARARGS, "SoVRMLExtrusion_orientation_set(SoVRMLExtrusion self, SoMFRotation orientation)"},
	 { "SoVRMLExtrusion_orientation_get", _wrap_SoVRMLExtrusion_orientation_get, METH_O, "SoVRMLExtrusion_orientation_get(SoVRMLExtrusion self) -> SoMFRotation"},
	 { "SoVRMLExtrusion_scale_set", _wrap_SoVRMLExtrusion_scale_set, METH_VARARGS, "SoVRMLExtrusion_scale_set(SoVRMLExtrusion self, SoMFVec2f scale)"},
	 { "SoVRMLExtrusion_scale_get", _wrap_SoVRMLExtrusion_scale_get, METH_O, "SoVRMLExtrusion_scale_get(SoVRMLExtrusion self) -> SoMFVec2f"},
	 { "SoVRMLExtrusion_solid_set", _wrap_SoVRMLExtrusion_solid_set, METH_VARARGS, "SoVRMLExtrusion_solid_set(SoVRMLExtrusion self, SoSFBool solid)"},
	 { "SoVRMLExtrusion_solid_get", _wrap_SoVRMLExtrusion_solid_get, METH_O, "SoVRMLExtrusion_solid_get(SoVRMLExtrusion self) -> SoSFBool"},
	 { "SoVRMLExtrusion_spine_set", _wrap_SoVRMLExtrusion_spine_set, METH_VARARGS, "SoVRMLExtrusion_spine_set(SoVRMLExtrusion self, SoMFVec3f spine)"},
	 { "SoVRMLExtrusion_spine_get", _wrap_SoVRMLExtrusion_spine_get, METH_O, "SoVRMLExtrusion_spine_get(SoVRMLExtrusion self) -> SoMFVec3f"},
	 { "SoVRMLExtrusion_GLRender", _wrap_SoVRMLExtrusion_GLRender, METH_VARARGS, "SoVRMLExtrusion_GLRender(SoVRMLExtrusion self, SoGLRenderAction action)"},
	 { "SoVRMLExtrusion_getPrimitiveCount", _wrap_SoVRMLExtrusion_getPrimitiveCount, METH_VARARGS, "SoVRMLExtrusion_getPrimitiveCount(SoVRMLExtrusion self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLExtrusion_computeBBox", _wrap_SoVRMLExtrusion_computeBBox, METH_VARARGS, "SoVRMLExtrusion_computeBBox(SoVRMLExtrusion self, SoAction action, SbBox3f bbox, SbVec3f center)"},
	 { "SoVRMLExtrusion_swigregister", SoVRMLExtrusion_swigregister, METH_O, NULL},
	 { "SoVRMLExtrusion_swiginit", SoVRMLExtrusion_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLFog_getClassTypeId", _wrap_SoVRMLFog_getClassTypeId, METH_NOARGS, "SoVRMLFog_getClassTypeId() -> SoType"},
	 { "SoVRMLFog_getTypeId", _wrap_SoVRMLFog_getTypeId, METH_O, "SoVRMLFog_getTypeId(SoVRMLFog self) -> SoType"},
	 { "SoVRMLFog_initClass", _wrap_SoVRMLFog_initClass, METH_NOARGS, "SoVRMLFog_initClass()"},
	 { "new_SoVRMLFog", _wrap_new_SoVRMLFog, METH_NOARGS, "new_SoVRMLFog() -> SoVRMLFog"},
	 { "SoVRMLFog_fogType_set", _wrap_SoVRMLFog_fogType_set, METH_VARARGS, "SoVRMLFog_fogType_set(SoVRMLFog self, SoSFString fogType)"},
	 { "SoVRMLFog_fogType_get", _wrap_SoVRMLFog_fogType_get, METH_O, "SoVRMLFog_fogType_get(SoVRMLFog self) -> SoSFString"},
	 { "SoVRMLFog_visibilityRange_set", _wrap_SoVRMLFog_visibilityRange_set, METH_VARARGS, "SoVRMLFog_visibilityRange_set(SoVRMLFog self, SoSFFloat visibilityRange)"},
	 { "SoVRMLFog_visibilityRange_get", _wrap_SoVRMLFog_visibilityRange_get, METH_O, "SoVRMLFog_visibilityRange_get(SoVRMLFog self) -> SoSFFloat"},
	 { "SoVRMLFog_color_set", _wrap_SoVRMLFog_color_set, METH_VARARGS, "SoVRMLFog_color_set(SoVRMLFog self, SoSFColor color)"},
	 { "SoVRMLFog_color_get", _wrap_SoVRMLFog_color_get, METH_O, "SoVRMLFog_color_get(SoVRMLFog self) -> SoSFColor"},
	 { "SoVRMLFog_GLRender", _wrap_SoVRMLFog_GLRender, METH_VARARGS, "SoVRMLFog_GLRender(SoVRMLFog self, SoGLRenderAction action)"},
	 { "SoVRMLFog_swigregister", SoVRMLFog_swigregister, METH_O, NULL},
	 { "SoVRMLFog_swiginit", SoVRMLFog_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLFontStyle_getClassTypeId", _wrap_SoVRMLFontStyle_getClassTypeId, METH_NOARGS, "SoVRMLFontStyle_getClassTypeId() -> SoType"},
	 { "SoVRMLFontStyle_getTypeId", _wrap_SoVRMLFontStyle_getTypeId, METH_O, "SoVRMLFontStyle_getTypeId(SoVRMLFontStyle self) -> SoType"},
	 { "SoVRMLFontStyle_initClass", _wrap_SoVRMLFontStyle_initClass, METH_NOARGS, "SoVRMLFontStyle_initClass()"},
	 { "new_SoVRMLFontStyle", _wrap_new_SoVRMLFontStyle, METH_NOARGS, "new_SoVRMLFontStyle() -> SoVRMLFontStyle"},
	 { "SoVRMLFontStyle_size_set", _wrap_SoVRMLFontStyle_size_set, METH_VARARGS, "SoVRMLFontStyle_size_set(SoVRMLFontStyle self, SoSFFloat size)"},
	 { "SoVRMLFontStyle_size_get", _wrap_SoVRMLFontStyle_size_get, METH_O, "SoVRMLFontStyle_size_get(SoVRMLFontStyle self) -> SoSFFloat"},
	 { "SoVRMLFontStyle_family_set", _wrap_SoVRMLFontStyle_family_set, METH_VARARGS, "SoVRMLFontStyle_family_set(SoVRMLFontStyle self, SoMFString family)"},
	 { "SoVRMLFontStyle_family_get", _wrap_SoVRMLFontStyle_family_get, METH_O, "SoVRMLFontStyle_family_get(SoVRMLFontStyle self) -> SoMFString"},
	 { "SoVRMLFontStyle_style_set", _wrap_SoVRMLFontStyle_style_set, METH_VARARGS, "SoVRMLFontStyle_style_set(SoVRMLFontStyle self, SoMFString style)"},
	 { "SoVRMLFontStyle_style_get", _wrap_SoVRMLFontStyle_style_get, METH_O, "SoVRMLFontStyle_style_get(SoVRMLFontStyle self) -> SoMFString"},
	 { "SoVRMLFontStyle_horizontal_set", _wrap_SoVRMLFontStyle_horizontal_set, METH_VARARGS, "SoVRMLFontStyle_horizontal_set(SoVRMLFontStyle self, SoSFBool horizontal)"},
	 { "SoVRMLFontStyle_horizontal_get", _wrap_SoVRMLFontStyle_horizontal_get, METH_O, "SoVRMLFontStyle_horizontal_get(SoVRMLFontStyle self) -> SoSFBool"},
	 { "SoVRMLFontStyle_leftToRight_set", _wrap_SoVRMLFontStyle_leftToRight_set, METH_VARARGS, "SoVRMLFontStyle_leftToRight_set(SoVRMLFontStyle self, SoSFBool leftToRight)"},
	 { "SoVRMLFontStyle_leftToRight_get", _wrap_SoVRMLFontStyle_leftToRight_get, METH_O, "SoVRMLFontStyle_leftToRight_get(SoVRMLFontStyle self) -> SoSFBool"},
	 { "SoVRMLFontStyle_topToBottom_set", _wrap_SoVRMLFontStyle_topToBottom_set, METH_VARARGS, "SoVRMLFontStyle_topToBottom_set(SoVRMLFontStyle self, SoSFBool topToBottom)"},
	 { "SoVRMLFontStyle_topToBottom_get", _wrap_SoVRMLFontStyle_topToBottom_get, METH_O, "SoVRMLFontStyle_topToBottom_get(SoVRMLFontStyle self) -> SoSFBool"},
	 { "SoVRMLFontStyle_language_set", _wrap_SoVRMLFontStyle_language_set, METH_VARARGS, "SoVRMLFontStyle_language_set(SoVRMLFontStyle self, SoSFString language)"},
	 { "SoVRMLFontStyle_language_get", _wrap_SoVRMLFontStyle_language_get, METH_O, "SoVRMLFontStyle_language_get(SoVRMLFontStyle self) -> SoSFString"},
	 { "SoVRMLFontStyle_justify_set", _wrap_SoVRMLFontStyle_justify_set, METH_VARARGS, "SoVRMLFontStyle_justify_set(SoVRMLFontStyle self, SoMFString justify)"},
	 { "SoVRMLFontStyle_justify_get", _wrap_SoVRMLFontStyle_justify_get, METH_O, "SoVRMLFontStyle_justify_get(SoVRMLFontStyle self) -> SoMFString"},
	 { "SoVRMLFontStyle_spacing_set", _wrap_SoVRMLFontStyle_spacing_set, METH_VARARGS, "SoVRMLFontStyle_spacing_set(SoVRMLFontStyle self, SoSFFloat spacing)"},
	 { "SoVRMLFontStyle_spacing_get", _wrap_SoVRMLFontStyle_spacing_get, METH_O, "SoVRMLFontStyle_spacing_get(SoVRMLFontStyle self) -> SoSFFloat"},
	 { "SoVRMLFontStyle_getFontName", _wrap_SoVRMLFontStyle_getFontName, METH_O, "SoVRMLFontStyle_getFontName(SoVRMLFontStyle self) -> SbString"},
	 { "SoVRMLFontStyle_doAction", _wrap_SoVRMLFontStyle_doAction, METH_VARARGS, "SoVRMLFontStyle_doAction(SoVRMLFontStyle self, SoAction action)"},
	 { "SoVRMLFontStyle_callback", _wrap_SoVRMLFontStyle_callback, METH_VARARGS, "SoVRMLFontStyle_callback(SoVRMLFontStyle self, SoCallbackAction action)"},
	 { "SoVRMLFontStyle_GLRender", _wrap_SoVRMLFontStyle_GLRender, METH_VARARGS, "SoVRMLFontStyle_GLRender(SoVRMLFontStyle self, SoGLRenderAction action)"},
	 { "SoVRMLFontStyle_getBoundingBox", _wrap_SoVRMLFontStyle_getBoundingBox, METH_VARARGS, "SoVRMLFontStyle_getBoundingBox(SoVRMLFontStyle self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLFontStyle_pick", _wrap_SoVRMLFontStyle_pick, METH_VARARGS, "SoVRMLFontStyle_pick(SoVRMLFontStyle self, SoPickAction action)"},
	 { "SoVRMLFontStyle_getPrimitiveCount", _wrap_SoVRMLFontStyle_getPrimitiveCount, METH_VARARGS, "SoVRMLFontStyle_getPrimitiveCount(SoVRMLFontStyle self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLFontStyle_swigregister", SoVRMLFontStyle_swigregister, METH_O, NULL},
	 { "SoVRMLFontStyle_swiginit", SoVRMLFontStyle_swiginit, METH_VARARGS, NULL},
	 { "so_vrml_init", _wrap_so_vrml_init, METH_NOARGS, "so_vrml_init()"},
	 { "SoVRMLTexture_getClassTypeId", _wrap_SoVRMLTexture_getClassTypeId, METH_NOARGS, "SoVRMLTexture_getClassTypeId() -> SoType"},
	 { "SoVRMLTexture_getTypeId", _wrap_SoVRMLTexture_getTypeId, METH_O, "SoVRMLTexture_getTypeId(SoVRMLTexture self) -> SoType"},
	 { "SoVRMLTexture_initClass", _wrap_SoVRMLTexture_initClass, METH_NOARGS, "SoVRMLTexture_initClass()"},
	 { "SoVRMLTexture_repeatS_set", _wrap_SoVRMLTexture_repeatS_set, METH_VARARGS, "SoVRMLTexture_repeatS_set(SoVRMLTexture self, SoSFBool repeatS)"},
	 { "SoVRMLTexture_repeatS_get", _wrap_SoVRMLTexture_repeatS_get, METH_O, "SoVRMLTexture_repeatS_get(SoVRMLTexture self) -> SoSFBool"},
	 { "SoVRMLTexture_repeatT_set", _wrap_SoVRMLTexture_repeatT_set, METH_VARARGS, "SoVRMLTexture_repeatT_set(SoVRMLTexture self, SoSFBool repeatT)"},
	 { "SoVRMLTexture_repeatT_get", _wrap_SoVRMLTexture_repeatT_get, METH_O, "SoVRMLTexture_repeatT_get(SoVRMLTexture self) -> SoSFBool"},
	 { "SoVRMLTexture_GLRender", _wrap_SoVRMLTexture_GLRender, METH_VARARGS, "SoVRMLTexture_GLRender(SoVRMLTexture self, SoGLRenderAction action)"},
	 { "SoVRMLTexture_swigregister", SoVRMLTexture_swigregister, METH_O, NULL},
	 { "SoVRMLImageTexture_getClassTypeId", _wrap_SoVRMLImageTexture_getClassTypeId, METH_NOARGS, "SoVRMLImageTexture_getClassTypeId() -> SoType"},
	 { "SoVRMLImageTexture_getTypeId", _wrap_SoVRMLImageTexture_getTypeId, METH_O, "SoVRMLImageTexture_getTypeId(SoVRMLImageTexture self) -> SoType"},
	 { "SoVRMLImageTexture_initClass", _wrap_SoVRMLImageTexture_initClass, METH_NOARGS, "SoVRMLImageTexture_initClass()"},
	 { "new_SoVRMLImageTexture", _wrap_new_SoVRMLImageTexture, METH_NOARGS, "new_SoVRMLImageTexture() -> SoVRMLImageTexture"},
	 { "SoVRMLImageTexture_url_set", _wrap_SoVRMLImageTexture_url_set, METH_VARARGS, "SoVRMLImageTexture_url_set(SoVRMLImageTexture self, SoMFString url)"},
	 { "SoVRMLImageTexture_url_get", _wrap_SoVRMLImageTexture_url_get, METH_O, "SoVRMLImageTexture_url_get(SoVRMLImageTexture self) -> SoMFString"},
	 { "SoVRMLImageTexture_setDelayFetchURL", _wrap_SoVRMLImageTexture_setDelayFetchURL, METH_O, "SoVRMLImageTexture_setDelayFetchURL(SbBool const onoff)"},
	 { "SoVRMLImageTexture_setPrequalifyFileCallBack", _wrap_SoVRMLImageTexture_setPrequalifyFileCallBack, METH_VARARGS, "SoVRMLImageTexture_setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"},
	 { "SoVRMLImageTexture_allowPrequalifyFile", _wrap_SoVRMLImageTexture_allowPrequalifyFile, METH_VARARGS, "SoVRMLImageTexture_allowPrequalifyFile(SoVRMLImageTexture self, SbBool enable)"},
	 { "SoVRMLImageTexture_doAction", _wrap_SoVRMLImageTexture_doAction, METH_VARARGS, "SoVRMLImageTexture_doAction(SoVRMLImageTexture self, SoAction action)"},
	 { "SoVRMLImageTexture_GLRender", _wrap_SoVRMLImageTexture_GLRender, METH_VARARGS, "SoVRMLImageTexture_GLRender(SoVRMLImageTexture self, SoGLRenderAction action)"},
	 { "SoVRMLImageTexture_callback", _wrap_SoVRMLImageTexture_callback, METH_VARARGS, "SoVRMLImageTexture_callback(SoVRMLImageTexture self, SoCallbackAction action)"},
	 { "SoVRMLImageTexture_rayPick", _wrap_SoVRMLImageTexture_rayPick, METH_VARARGS, "SoVRMLImageTexture_rayPick(SoVRMLImageTexture self, SoRayPickAction action)"},
	 { "SoVRMLImageTexture_setImage", _wrap_SoVRMLImageTexture_setImage, METH_VARARGS, "SoVRMLImageTexture_setImage(SoVRMLImageTexture self, SbImage image)"},
	 { "SoVRMLImageTexture_getImage", _wrap_SoVRMLImageTexture_getImage, METH_O, "SoVRMLImageTexture_getImage(SoVRMLImageTexture self) -> SbImage"},
	 { "SoVRMLImageTexture_setImageDataMaxAge", _wrap_SoVRMLImageTexture_setImageDataMaxAge, METH_O, "SoVRMLImageTexture_setImageDataMaxAge(uint32_t const maxage)"},
	 { "SoVRMLImageTexture_swigregister", SoVRMLImageTexture_swigregister, METH_O, NULL},
	 { "SoVRMLImageTexture_swiginit", SoVRMLImageTexture_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLVertexShape_getClassTypeId", _wrap_SoVRMLVertexShape_getClassTypeId, METH_NOARGS, "SoVRMLVertexShape_getClassTypeId() -> SoType"},
	 { "SoVRMLVertexShape_getTypeId", _wrap_SoVRMLVertexShape_getTypeId, METH_O, "SoVRMLVertexShape_getTypeId(SoVRMLVertexShape self) -> SoType"},
	 { "SoVRMLVertexShape_initClass", _wrap_SoVRMLVertexShape_initClass, METH_NOARGS, "SoVRMLVertexShape_initClass()"},
	 { "SoVRMLVertexShape_coord_set", _wrap_SoVRMLVertexShape_coord_set, METH_VARARGS, "SoVRMLVertexShape_coord_set(SoVRMLVertexShape self, SoSFNode coord)"},
	 { "SoVRMLVertexShape_coord_get", _wrap_SoVRMLVertexShape_coord_get, METH_O, "SoVRMLVertexShape_coord_get(SoVRMLVertexShape self) -> SoSFNode"},
	 { "SoVRMLVertexShape_texCoord_set", _wrap_SoVRMLVertexShape_texCoord_set, METH_VARARGS, "SoVRMLVertexShape_texCoord_set(SoVRMLVertexShape self, SoSFNode texCoord)"},
	 { "SoVRMLVertexShape_texCoord_get", _wrap_SoVRMLVertexShape_texCoord_get, METH_O, "SoVRMLVertexShape_texCoord_get(SoVRMLVertexShape self) -> SoSFNode"},
	 { "SoVRMLVertexShape_normal_set", _wrap_SoVRMLVertexShape_normal_set, METH_VARARGS, "SoVRMLVertexShape_normal_set(SoVRMLVertexShape self, SoSFNode normal)"},
	 { "SoVRMLVertexShape_normal_get", _wrap_SoVRMLVertexShape_normal_get, METH_O, "SoVRMLVertexShape_normal_get(SoVRMLVertexShape self) -> SoSFNode"},
	 { "SoVRMLVertexShape_color_set", _wrap_SoVRMLVertexShape_color_set, METH_VARARGS, "SoVRMLVertexShape_color_set(SoVRMLVertexShape self, SoSFNode color)"},
	 { "SoVRMLVertexShape_color_get", _wrap_SoVRMLVertexShape_color_get, METH_O, "SoVRMLVertexShape_color_get(SoVRMLVertexShape self) -> SoSFNode"},
	 { "SoVRMLVertexShape_colorPerVertex_set", _wrap_SoVRMLVertexShape_colorPerVertex_set, METH_VARARGS, "SoVRMLVertexShape_colorPerVertex_set(SoVRMLVertexShape self, SoSFBool colorPerVertex)"},
	 { "SoVRMLVertexShape_colorPerVertex_get", _wrap_SoVRMLVertexShape_colorPerVertex_get, METH_O, "SoVRMLVertexShape_colorPerVertex_get(SoVRMLVertexShape self) -> SoSFBool"},
	 { "SoVRMLVertexShape_normalPerVertex_set", _wrap_SoVRMLVertexShape_normalPerVertex_set, METH_VARARGS, "SoVRMLVertexShape_normalPerVertex_set(SoVRMLVertexShape self, SoSFBool normalPerVertex)"},
	 { "SoVRMLVertexShape_normalPerVertex_get", _wrap_SoVRMLVertexShape_normalPerVertex_get, METH_O, "SoVRMLVertexShape_normalPerVertex_get(SoVRMLVertexShape self) -> SoSFBool"},
	 { "SoVRMLVertexShape_generateDefaultNormals", _wrap_SoVRMLVertexShape_generateDefaultNormals, METH_VARARGS, "\n"
		"SoVRMLVertexShape_generateDefaultNormals(SoVRMLVertexShape self, SoState s, SoNormalBundle nb) -> SbBool\n"
		"SoVRMLVertexShape_generateDefaultNormals(SoVRMLVertexShape self, SoState s, SoNormalCache nc) -> SbBool\n"
		""},
	 { "SoVRMLVertexShape_doAction", _wrap_SoVRMLVertexShape_doAction, METH_VARARGS, "SoVRMLVertexShape_doAction(SoVRMLVertexShape self, SoAction action)"},
	 { "SoVRMLVertexShape_GLRender", _wrap_SoVRMLVertexShape_GLRender, METH_VARARGS, "SoVRMLVertexShape_GLRender(SoVRMLVertexShape self, SoGLRenderAction action)"},
	 { "SoVRMLVertexShape_getBoundingBox", _wrap_SoVRMLVertexShape_getBoundingBox, METH_VARARGS, "SoVRMLVertexShape_getBoundingBox(SoVRMLVertexShape self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLVertexShape_callback", _wrap_SoVRMLVertexShape_callback, METH_VARARGS, "SoVRMLVertexShape_callback(SoVRMLVertexShape self, SoCallbackAction action)"},
	 { "SoVRMLVertexShape_pick", _wrap_SoVRMLVertexShape_pick, METH_VARARGS, "SoVRMLVertexShape_pick(SoVRMLVertexShape self, SoPickAction action)"},
	 { "SoVRMLVertexShape_notify", _wrap_SoVRMLVertexShape_notify, METH_VARARGS, "SoVRMLVertexShape_notify(SoVRMLVertexShape self, SoNotList list)"},
	 { "SoVRMLVertexShape_swigregister", SoVRMLVertexShape_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedShape_getClassTypeId", _wrap_SoVRMLIndexedShape_getClassTypeId, METH_NOARGS, "SoVRMLIndexedShape_getClassTypeId() -> SoType"},
	 { "SoVRMLIndexedShape_getTypeId", _wrap_SoVRMLIndexedShape_getTypeId, METH_O, "SoVRMLIndexedShape_getTypeId(SoVRMLIndexedShape self) -> SoType"},
	 { "SoVRMLIndexedShape_initClass", _wrap_SoVRMLIndexedShape_initClass, METH_NOARGS, "SoVRMLIndexedShape_initClass()"},
	 { "SoVRMLIndexedShape_coordIndex_set", _wrap_SoVRMLIndexedShape_coordIndex_set, METH_VARARGS, "SoVRMLIndexedShape_coordIndex_set(SoVRMLIndexedShape self, SoMFInt32 coordIndex)"},
	 { "SoVRMLIndexedShape_coordIndex_get", _wrap_SoVRMLIndexedShape_coordIndex_get, METH_O, "SoVRMLIndexedShape_coordIndex_get(SoVRMLIndexedShape self) -> SoMFInt32"},
	 { "SoVRMLIndexedShape_colorIndex_set", _wrap_SoVRMLIndexedShape_colorIndex_set, METH_VARARGS, "SoVRMLIndexedShape_colorIndex_set(SoVRMLIndexedShape self, SoMFInt32 colorIndex)"},
	 { "SoVRMLIndexedShape_colorIndex_get", _wrap_SoVRMLIndexedShape_colorIndex_get, METH_O, "SoVRMLIndexedShape_colorIndex_get(SoVRMLIndexedShape self) -> SoMFInt32"},
	 { "SoVRMLIndexedShape_normalIndex_set", _wrap_SoVRMLIndexedShape_normalIndex_set, METH_VARARGS, "SoVRMLIndexedShape_normalIndex_set(SoVRMLIndexedShape self, SoMFInt32 normalIndex)"},
	 { "SoVRMLIndexedShape_normalIndex_get", _wrap_SoVRMLIndexedShape_normalIndex_get, METH_O, "SoVRMLIndexedShape_normalIndex_get(SoVRMLIndexedShape self) -> SoMFInt32"},
	 { "SoVRMLIndexedShape_texCoordIndex_set", _wrap_SoVRMLIndexedShape_texCoordIndex_set, METH_VARARGS, "SoVRMLIndexedShape_texCoordIndex_set(SoVRMLIndexedShape self, SoMFInt32 texCoordIndex)"},
	 { "SoVRMLIndexedShape_texCoordIndex_get", _wrap_SoVRMLIndexedShape_texCoordIndex_get, METH_O, "SoVRMLIndexedShape_texCoordIndex_get(SoVRMLIndexedShape self) -> SoMFInt32"},
	 { "SoVRMLIndexedShape_swigregister", SoVRMLIndexedShape_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedFaceSet_getClassTypeId", _wrap_SoVRMLIndexedFaceSet_getClassTypeId, METH_NOARGS, "SoVRMLIndexedFaceSet_getClassTypeId() -> SoType"},
	 { "SoVRMLIndexedFaceSet_getTypeId", _wrap_SoVRMLIndexedFaceSet_getTypeId, METH_O, "SoVRMLIndexedFaceSet_getTypeId(SoVRMLIndexedFaceSet self) -> SoType"},
	 { "SoVRMLIndexedFaceSet_initClass", _wrap_SoVRMLIndexedFaceSet_initClass, METH_NOARGS, "SoVRMLIndexedFaceSet_initClass()"},
	 { "new_SoVRMLIndexedFaceSet", _wrap_new_SoVRMLIndexedFaceSet, METH_NOARGS, "new_SoVRMLIndexedFaceSet() -> SoVRMLIndexedFaceSet"},
	 { "SoVRMLIndexedFaceSet_ccw_set", _wrap_SoVRMLIndexedFaceSet_ccw_set, METH_VARARGS, "SoVRMLIndexedFaceSet_ccw_set(SoVRMLIndexedFaceSet self, SoSFBool ccw)"},
	 { "SoVRMLIndexedFaceSet_ccw_get", _wrap_SoVRMLIndexedFaceSet_ccw_get, METH_O, "SoVRMLIndexedFaceSet_ccw_get(SoVRMLIndexedFaceSet self) -> SoSFBool"},
	 { "SoVRMLIndexedFaceSet_solid_set", _wrap_SoVRMLIndexedFaceSet_solid_set, METH_VARARGS, "SoVRMLIndexedFaceSet_solid_set(SoVRMLIndexedFaceSet self, SoSFBool solid)"},
	 { "SoVRMLIndexedFaceSet_solid_get", _wrap_SoVRMLIndexedFaceSet_solid_get, METH_O, "SoVRMLIndexedFaceSet_solid_get(SoVRMLIndexedFaceSet self) -> SoSFBool"},
	 { "SoVRMLIndexedFaceSet_convex_set", _wrap_SoVRMLIndexedFaceSet_convex_set, METH_VARARGS, "SoVRMLIndexedFaceSet_convex_set(SoVRMLIndexedFaceSet self, SoSFBool convex)"},
	 { "SoVRMLIndexedFaceSet_convex_get", _wrap_SoVRMLIndexedFaceSet_convex_get, METH_O, "SoVRMLIndexedFaceSet_convex_get(SoVRMLIndexedFaceSet self) -> SoSFBool"},
	 { "SoVRMLIndexedFaceSet_creaseAngle_set", _wrap_SoVRMLIndexedFaceSet_creaseAngle_set, METH_VARARGS, "SoVRMLIndexedFaceSet_creaseAngle_set(SoVRMLIndexedFaceSet self, SoSFFloat creaseAngle)"},
	 { "SoVRMLIndexedFaceSet_creaseAngle_get", _wrap_SoVRMLIndexedFaceSet_creaseAngle_get, METH_O, "SoVRMLIndexedFaceSet_creaseAngle_get(SoVRMLIndexedFaceSet self) -> SoSFFloat"},
	 { "SoVRMLIndexedFaceSet_GLRender", _wrap_SoVRMLIndexedFaceSet_GLRender, METH_VARARGS, "SoVRMLIndexedFaceSet_GLRender(SoVRMLIndexedFaceSet self, SoGLRenderAction action)"},
	 { "SoVRMLIndexedFaceSet_getPrimitiveCount", _wrap_SoVRMLIndexedFaceSet_getPrimitiveCount, METH_VARARGS, "SoVRMLIndexedFaceSet_getPrimitiveCount(SoVRMLIndexedFaceSet self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLIndexedFaceSet_generateDefaultNormals", _wrap_SoVRMLIndexedFaceSet_generateDefaultNormals, METH_VARARGS, "\n"
		"SoVRMLIndexedFaceSet_generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState s, SoNormalBundle nb) -> SbBool\n"
		"SoVRMLIndexedFaceSet_generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState state, SoNormalCache nc) -> SbBool\n"
		""},
	 { "SoVRMLIndexedFaceSet_swigregister", SoVRMLIndexedFaceSet_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedFaceSet_swiginit", SoVRMLIndexedFaceSet_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLVertexLine_getClassTypeId", _wrap_SoVRMLVertexLine_getClassTypeId, METH_NOARGS, "SoVRMLVertexLine_getClassTypeId() -> SoType"},
	 { "SoVRMLVertexLine_getTypeId", _wrap_SoVRMLVertexLine_getTypeId, METH_O, "SoVRMLVertexLine_getTypeId(SoVRMLVertexLine self) -> SoType"},
	 { "SoVRMLVertexLine_initClass", _wrap_SoVRMLVertexLine_initClass, METH_NOARGS, "SoVRMLVertexLine_initClass()"},
	 { "SoVRMLVertexLine_coord_set", _wrap_SoVRMLVertexLine_coord_set, METH_VARARGS, "SoVRMLVertexLine_coord_set(SoVRMLVertexLine self, SoSFNode coord)"},
	 { "SoVRMLVertexLine_coord_get", _wrap_SoVRMLVertexLine_coord_get, METH_O, "SoVRMLVertexLine_coord_get(SoVRMLVertexLine self) -> SoSFNode"},
	 { "SoVRMLVertexLine_color_set", _wrap_SoVRMLVertexLine_color_set, METH_VARARGS, "SoVRMLVertexLine_color_set(SoVRMLVertexLine self, SoSFNode color)"},
	 { "SoVRMLVertexLine_color_get", _wrap_SoVRMLVertexLine_color_get, METH_O, "SoVRMLVertexLine_color_get(SoVRMLVertexLine self) -> SoSFNode"},
	 { "SoVRMLVertexLine_colorPerVertex_set", _wrap_SoVRMLVertexLine_colorPerVertex_set, METH_VARARGS, "SoVRMLVertexLine_colorPerVertex_set(SoVRMLVertexLine self, SoSFBool colorPerVertex)"},
	 { "SoVRMLVertexLine_colorPerVertex_get", _wrap_SoVRMLVertexLine_colorPerVertex_get, METH_O, "SoVRMLVertexLine_colorPerVertex_get(SoVRMLVertexLine self) -> SoSFBool"},
	 { "SoVRMLVertexLine_doAction", _wrap_SoVRMLVertexLine_doAction, METH_VARARGS, "SoVRMLVertexLine_doAction(SoVRMLVertexLine self, SoAction action)"},
	 { "SoVRMLVertexLine_GLRender", _wrap_SoVRMLVertexLine_GLRender, METH_VARARGS, "SoVRMLVertexLine_GLRender(SoVRMLVertexLine self, SoGLRenderAction action)"},
	 { "SoVRMLVertexLine_getBoundingBox", _wrap_SoVRMLVertexLine_getBoundingBox, METH_VARARGS, "SoVRMLVertexLine_getBoundingBox(SoVRMLVertexLine self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLVertexLine_callback", _wrap_SoVRMLVertexLine_callback, METH_VARARGS, "SoVRMLVertexLine_callback(SoVRMLVertexLine self, SoCallbackAction action)"},
	 { "SoVRMLVertexLine_pick", _wrap_SoVRMLVertexLine_pick, METH_VARARGS, "SoVRMLVertexLine_pick(SoVRMLVertexLine self, SoPickAction action)"},
	 { "SoVRMLVertexLine_notify", _wrap_SoVRMLVertexLine_notify, METH_VARARGS, "SoVRMLVertexLine_notify(SoVRMLVertexLine self, SoNotList list)"},
	 { "SoVRMLVertexLine_swigregister", SoVRMLVertexLine_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedLine_getClassTypeId", _wrap_SoVRMLIndexedLine_getClassTypeId, METH_NOARGS, "SoVRMLIndexedLine_getClassTypeId() -> SoType"},
	 { "SoVRMLIndexedLine_getTypeId", _wrap_SoVRMLIndexedLine_getTypeId, METH_O, "SoVRMLIndexedLine_getTypeId(SoVRMLIndexedLine self) -> SoType"},
	 { "SoVRMLIndexedLine_initClass", _wrap_SoVRMLIndexedLine_initClass, METH_NOARGS, "SoVRMLIndexedLine_initClass()"},
	 { "SoVRMLIndexedLine_coordIndex_set", _wrap_SoVRMLIndexedLine_coordIndex_set, METH_VARARGS, "SoVRMLIndexedLine_coordIndex_set(SoVRMLIndexedLine self, SoMFInt32 coordIndex)"},
	 { "SoVRMLIndexedLine_coordIndex_get", _wrap_SoVRMLIndexedLine_coordIndex_get, METH_O, "SoVRMLIndexedLine_coordIndex_get(SoVRMLIndexedLine self) -> SoMFInt32"},
	 { "SoVRMLIndexedLine_colorIndex_set", _wrap_SoVRMLIndexedLine_colorIndex_set, METH_VARARGS, "SoVRMLIndexedLine_colorIndex_set(SoVRMLIndexedLine self, SoMFInt32 colorIndex)"},
	 { "SoVRMLIndexedLine_colorIndex_get", _wrap_SoVRMLIndexedLine_colorIndex_get, METH_O, "SoVRMLIndexedLine_colorIndex_get(SoVRMLIndexedLine self) -> SoMFInt32"},
	 { "SoVRMLIndexedLine_swigregister", SoVRMLIndexedLine_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedLineSet_getClassTypeId", _wrap_SoVRMLIndexedLineSet_getClassTypeId, METH_NOARGS, "SoVRMLIndexedLineSet_getClassTypeId() -> SoType"},
	 { "SoVRMLIndexedLineSet_getTypeId", _wrap_SoVRMLIndexedLineSet_getTypeId, METH_O, "SoVRMLIndexedLineSet_getTypeId(SoVRMLIndexedLineSet self) -> SoType"},
	 { "SoVRMLIndexedLineSet_initClass", _wrap_SoVRMLIndexedLineSet_initClass, METH_NOARGS, "SoVRMLIndexedLineSet_initClass()"},
	 { "new_SoVRMLIndexedLineSet", _wrap_new_SoVRMLIndexedLineSet, METH_NOARGS, "new_SoVRMLIndexedLineSet() -> SoVRMLIndexedLineSet"},
	 { "SoVRMLIndexedLineSet_GLRender", _wrap_SoVRMLIndexedLineSet_GLRender, METH_VARARGS, "SoVRMLIndexedLineSet_GLRender(SoVRMLIndexedLineSet self, SoGLRenderAction action)"},
	 { "SoVRMLIndexedLineSet_getPrimitiveCount", _wrap_SoVRMLIndexedLineSet_getPrimitiveCount, METH_VARARGS, "SoVRMLIndexedLineSet_getPrimitiveCount(SoVRMLIndexedLineSet self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLIndexedLineSet_getBoundingBox", _wrap_SoVRMLIndexedLineSet_getBoundingBox, METH_VARARGS, "SoVRMLIndexedLineSet_getBoundingBox(SoVRMLIndexedLineSet self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLIndexedLineSet_swigregister", SoVRMLIndexedLineSet_swigregister, METH_O, NULL},
	 { "SoVRMLIndexedLineSet_swiginit", SoVRMLIndexedLineSet_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLInline_getClassTypeId", _wrap_SoVRMLInline_getClassTypeId, METH_NOARGS, "SoVRMLInline_getClassTypeId() -> SoType"},
	 { "SoVRMLInline_getTypeId", _wrap_SoVRMLInline_getTypeId, METH_O, "SoVRMLInline_getTypeId(SoVRMLInline self) -> SoType"},
	 { "SoVRMLInline_initClass", _wrap_SoVRMLInline_initClass, METH_NOARGS, "SoVRMLInline_initClass()"},
	 { "new_SoVRMLInline", _wrap_new_SoVRMLInline, METH_NOARGS, "new_SoVRMLInline() -> SoVRMLInline"},
	 { "SoVRMLInline_bboxCenter_set", _wrap_SoVRMLInline_bboxCenter_set, METH_VARARGS, "SoVRMLInline_bboxCenter_set(SoVRMLInline self, SoSFVec3f bboxCenter)"},
	 { "SoVRMLInline_bboxCenter_get", _wrap_SoVRMLInline_bboxCenter_get, METH_O, "SoVRMLInline_bboxCenter_get(SoVRMLInline self) -> SoSFVec3f"},
	 { "SoVRMLInline_bboxSize_set", _wrap_SoVRMLInline_bboxSize_set, METH_VARARGS, "SoVRMLInline_bboxSize_set(SoVRMLInline self, SoSFVec3f bboxSize)"},
	 { "SoVRMLInline_bboxSize_get", _wrap_SoVRMLInline_bboxSize_get, METH_O, "SoVRMLInline_bboxSize_get(SoVRMLInline self) -> SoSFVec3f"},
	 { "SoVRMLInline_url_set", _wrap_SoVRMLInline_url_set, METH_VARARGS, "SoVRMLInline_url_set(SoVRMLInline self, SoMFString url)"},
	 { "SoVRMLInline_url_get", _wrap_SoVRMLInline_url_get, METH_O, "SoVRMLInline_url_get(SoVRMLInline self) -> SoMFString"},
	 { "SoVRMLInline_setFullURLName", _wrap_SoVRMLInline_setFullURLName, METH_VARARGS, "SoVRMLInline_setFullURLName(SoVRMLInline self, SbString url)"},
	 { "SoVRMLInline_getFullURLName", _wrap_SoVRMLInline_getFullURLName, METH_O, "SoVRMLInline_getFullURLName(SoVRMLInline self) -> SbString"},
	 { "SoVRMLInline_copyChildren", _wrap_SoVRMLInline_copyChildren, METH_O, "SoVRMLInline_copyChildren(SoVRMLInline self) -> SoGroup"},
	 { "SoVRMLInline_requestURLData", _wrap_SoVRMLInline_requestURLData, METH_O, "SoVRMLInline_requestURLData(SoVRMLInline self)"},
	 { "SoVRMLInline_isURLDataRequested", _wrap_SoVRMLInline_isURLDataRequested, METH_O, "SoVRMLInline_isURLDataRequested(SoVRMLInline self) -> SbBool"},
	 { "SoVRMLInline_isURLDataHere", _wrap_SoVRMLInline_isURLDataHere, METH_O, "SoVRMLInline_isURLDataHere(SoVRMLInline self) -> SbBool"},
	 { "SoVRMLInline_cancelURLDataRequest", _wrap_SoVRMLInline_cancelURLDataRequest, METH_O, "SoVRMLInline_cancelURLDataRequest(SoVRMLInline self)"},
	 { "SoVRMLInline_setChildData", _wrap_SoVRMLInline_setChildData, METH_VARARGS, "SoVRMLInline_setChildData(SoVRMLInline self, SoNode urlData)"},
	 { "SoVRMLInline_getChildData", _wrap_SoVRMLInline_getChildData, METH_O, "SoVRMLInline_getChildData(SoVRMLInline self) -> SoNode"},
	 { "SoVRMLInline_setFetchURLCallBack", _wrap_SoVRMLInline_setFetchURLCallBack, METH_VARARGS, "SoVRMLInline_setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"},
	 { "SoVRMLInline_setBoundingBoxVisibility", _wrap_SoVRMLInline_setBoundingBoxVisibility, METH_O, "SoVRMLInline_setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"},
	 { "SoVRMLInline_getBoundingBoxVisibility", _wrap_SoVRMLInline_getBoundingBoxVisibility, METH_NOARGS, "SoVRMLInline_getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"},
	 { "SoVRMLInline_setBoundingBoxColor", _wrap_SoVRMLInline_setBoundingBoxColor, METH_O, "SoVRMLInline_setBoundingBoxColor(SbColor color)"},
	 { "SoVRMLInline_getBoundingBoxColor", _wrap_SoVRMLInline_getBoundingBoxColor, METH_NOARGS, "SoVRMLInline_getBoundingBoxColor() -> SbColor"},
	 { "SoVRMLInline_setReadAsSoFile", _wrap_SoVRMLInline_setReadAsSoFile, METH_O, "SoVRMLInline_setReadAsSoFile(SbBool enable)"},
	 { "SoVRMLInline_getReadAsSoFile", _wrap_SoVRMLInline_getReadAsSoFile, METH_NOARGS, "SoVRMLInline_getReadAsSoFile() -> SbBool"},
	 { "SoVRMLInline_doAction", _wrap_SoVRMLInline_doAction, METH_VARARGS, "SoVRMLInline_doAction(SoVRMLInline self, SoAction action)"},
	 { "SoVRMLInline_callback", _wrap_SoVRMLInline_callback, METH_VARARGS, "SoVRMLInline_callback(SoVRMLInline self, SoCallbackAction action)"},
	 { "SoVRMLInline_GLRender", _wrap_SoVRMLInline_GLRender, METH_VARARGS, "SoVRMLInline_GLRender(SoVRMLInline self, SoGLRenderAction action)"},
	 { "SoVRMLInline_getBoundingBox", _wrap_SoVRMLInline_getBoundingBox, METH_VARARGS, "SoVRMLInline_getBoundingBox(SoVRMLInline self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLInline_getMatrix", _wrap_SoVRMLInline_getMatrix, METH_VARARGS, "SoVRMLInline_getMatrix(SoVRMLInline self, SoGetMatrixAction action)"},
	 { "SoVRMLInline_handleEvent", _wrap_SoVRMLInline_handleEvent, METH_VARARGS, "SoVRMLInline_handleEvent(SoVRMLInline self, SoHandleEventAction action)"},
	 { "SoVRMLInline_search", _wrap_SoVRMLInline_search, METH_VARARGS, "SoVRMLInline_search(SoVRMLInline self, SoSearchAction action)"},
	 { "SoVRMLInline_pick", _wrap_SoVRMLInline_pick, METH_VARARGS, "SoVRMLInline_pick(SoVRMLInline self, SoPickAction action)"},
	 { "SoVRMLInline_getPrimitiveCount", _wrap_SoVRMLInline_getPrimitiveCount, METH_VARARGS, "SoVRMLInline_getPrimitiveCount(SoVRMLInline self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLInline_getChildren", _wrap_SoVRMLInline_getChildren, METH_O, "SoVRMLInline_getChildren(SoVRMLInline self) -> SoChildList"},
	 { "SoVRMLInline_swigregister", SoVRMLInline_swigregister, METH_O, NULL},
	 { "SoVRMLInline_swiginit", SoVRMLInline_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLLOD_getClassTypeId", _wrap_SoVRMLLOD_getClassTypeId, METH_NOARGS, "SoVRMLLOD_getClassTypeId() -> SoType"},
	 { "SoVRMLLOD_getTypeId", _wrap_SoVRMLLOD_getTypeId, METH_O, "SoVRMLLOD_getTypeId(SoVRMLLOD self) -> SoType"},
	 { "SoVRMLLOD_initClass", _wrap_SoVRMLLOD_initClass, METH_NOARGS, "SoVRMLLOD_initClass()"},
	 { "new_SoVRMLLOD", _wrap_new_SoVRMLLOD, METH_VARARGS, "\n"
		"SoVRMLLOD()\n"
		"new_SoVRMLLOD(int levels) -> SoVRMLLOD\n"
		""},
	 { "SoVRMLLOD_range_set", _wrap_SoVRMLLOD_range_set, METH_VARARGS, "SoVRMLLOD_range_set(SoVRMLLOD self, SoMFFloat range)"},
	 { "SoVRMLLOD_range_get", _wrap_SoVRMLLOD_range_get, METH_O, "SoVRMLLOD_range_get(SoVRMLLOD self) -> SoMFFloat"},
	 { "SoVRMLLOD_center_set", _wrap_SoVRMLLOD_center_set, METH_VARARGS, "SoVRMLLOD_center_set(SoVRMLLOD self, SoSFVec3f center)"},
	 { "SoVRMLLOD_center_get", _wrap_SoVRMLLOD_center_get, METH_O, "SoVRMLLOD_center_get(SoVRMLLOD self) -> SoSFVec3f"},
	 { "SoVRMLLOD_level_set", _wrap_SoVRMLLOD_level_set, METH_VARARGS, "SoVRMLLOD_level_set(SoVRMLLOD self, SoMFNode level)"},
	 { "SoVRMLLOD_level_get", _wrap_SoVRMLLOD_level_get, METH_O, "SoVRMLLOD_level_get(SoVRMLLOD self) -> SoMFNode"},
	 { "SoVRMLLOD_affectsState", _wrap_SoVRMLLOD_affectsState, METH_O, "SoVRMLLOD_affectsState(SoVRMLLOD self) -> SbBool"},
	 { "SoVRMLLOD_addLevel", _wrap_SoVRMLLOD_addLevel, METH_VARARGS, "SoVRMLLOD_addLevel(SoVRMLLOD self, SoNode level)"},
	 { "SoVRMLLOD_insertLevel", _wrap_SoVRMLLOD_insertLevel, METH_VARARGS, "SoVRMLLOD_insertLevel(SoVRMLLOD self, SoNode level, int idx)"},
	 { "SoVRMLLOD_getLevel", _wrap_SoVRMLLOD_getLevel, METH_VARARGS, "SoVRMLLOD_getLevel(SoVRMLLOD self, int idx) -> SoNode"},
	 { "SoVRMLLOD_findLevel", _wrap_SoVRMLLOD_findLevel, METH_VARARGS, "SoVRMLLOD_findLevel(SoVRMLLOD self, SoNode level) -> int"},
	 { "SoVRMLLOD_getNumLevels", _wrap_SoVRMLLOD_getNumLevels, METH_O, "SoVRMLLOD_getNumLevels(SoVRMLLOD self) -> int"},
	 { "SoVRMLLOD_removeLevel", _wrap_SoVRMLLOD_removeLevel, METH_VARARGS, "\n"
		"SoVRMLLOD_removeLevel(SoVRMLLOD self, int idx)\n"
		"SoVRMLLOD_removeLevel(SoVRMLLOD self, SoNode level)\n"
		""},
	 { "SoVRMLLOD_removeAllLevels", _wrap_SoVRMLLOD_removeAllLevels, METH_O, "SoVRMLLOD_removeAllLevels(SoVRMLLOD self)"},
	 { "SoVRMLLOD_replaceLevel", _wrap_SoVRMLLOD_replaceLevel, METH_VARARGS, "\n"
		"SoVRMLLOD_replaceLevel(SoVRMLLOD self, int idx, SoNode level)\n"
		"SoVRMLLOD_replaceLevel(SoVRMLLOD self, SoNode old, SoNode level)\n"
		""},
	 { "SoVRMLLOD_doAction", _wrap_SoVRMLLOD_doAction, METH_VARARGS, "SoVRMLLOD_doAction(SoVRMLLOD self, SoAction action)"},
	 { "SoVRMLLOD_callback", _wrap_SoVRMLLOD_callback, METH_VARARGS, "SoVRMLLOD_callback(SoVRMLLOD self, SoCallbackAction action)"},
	 { "SoVRMLLOD_GLRender", _wrap_SoVRMLLOD_GLRender, METH_VARARGS, "SoVRMLLOD_GLRender(SoVRMLLOD self, SoGLRenderAction action)"},
	 { "SoVRMLLOD_rayPick", _wrap_SoVRMLLOD_rayPick, METH_VARARGS, "SoVRMLLOD_rayPick(SoVRMLLOD self, SoRayPickAction action)"},
	 { "SoVRMLLOD_getBoundingBox", _wrap_SoVRMLLOD_getBoundingBox, METH_VARARGS, "SoVRMLLOD_getBoundingBox(SoVRMLLOD self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLLOD_search", _wrap_SoVRMLLOD_search, METH_VARARGS, "SoVRMLLOD_search(SoVRMLLOD self, SoSearchAction action)"},
	 { "SoVRMLLOD_write", _wrap_SoVRMLLOD_write, METH_VARARGS, "SoVRMLLOD_write(SoVRMLLOD self, SoWriteAction action)"},
	 { "SoVRMLLOD_getPrimitiveCount", _wrap_SoVRMLLOD_getPrimitiveCount, METH_VARARGS, "SoVRMLLOD_getPrimitiveCount(SoVRMLLOD self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLLOD_audioRender", _wrap_SoVRMLLOD_audioRender, METH_VARARGS, "SoVRMLLOD_audioRender(SoVRMLLOD self, SoAudioRenderAction action)"},
	 { "SoVRMLLOD_GLRenderBelowPath", _wrap_SoVRMLLOD_GLRenderBelowPath, METH_VARARGS, "SoVRMLLOD_GLRenderBelowPath(SoVRMLLOD self, SoGLRenderAction action)"},
	 { "SoVRMLLOD_GLRenderInPath", _wrap_SoVRMLLOD_GLRenderInPath, METH_VARARGS, "SoVRMLLOD_GLRenderInPath(SoVRMLLOD self, SoGLRenderAction action)"},
	 { "SoVRMLLOD_GLRenderOffPath", _wrap_SoVRMLLOD_GLRenderOffPath, METH_VARARGS, "SoVRMLLOD_GLRenderOffPath(SoVRMLLOD self, SoGLRenderAction action)"},
	 { "SoVRMLLOD_addChild", _wrap_SoVRMLLOD_addChild, METH_VARARGS, "SoVRMLLOD_addChild(SoVRMLLOD self, SoNode child)"},
	 { "SoVRMLLOD_insertChild", _wrap_SoVRMLLOD_insertChild, METH_VARARGS, "SoVRMLLOD_insertChild(SoVRMLLOD self, SoNode child, int idx)"},
	 { "SoVRMLLOD_getChild", _wrap_SoVRMLLOD_getChild, METH_VARARGS, "SoVRMLLOD_getChild(SoVRMLLOD self, int idx) -> SoNode"},
	 { "SoVRMLLOD_findChild", _wrap_SoVRMLLOD_findChild, METH_VARARGS, "SoVRMLLOD_findChild(SoVRMLLOD self, SoNode child) -> int"},
	 { "SoVRMLLOD_getNumChildren", _wrap_SoVRMLLOD_getNumChildren, METH_O, "SoVRMLLOD_getNumChildren(SoVRMLLOD self) -> int"},
	 { "SoVRMLLOD_removeChild", _wrap_SoVRMLLOD_removeChild, METH_VARARGS, "\n"
		"SoVRMLLOD_removeChild(SoVRMLLOD self, int idx)\n"
		"SoVRMLLOD_removeChild(SoVRMLLOD self, SoNode child)\n"
		""},
	 { "SoVRMLLOD_removeAllChildren", _wrap_SoVRMLLOD_removeAllChildren, METH_O, "SoVRMLLOD_removeAllChildren(SoVRMLLOD self)"},
	 { "SoVRMLLOD_replaceChild", _wrap_SoVRMLLOD_replaceChild, METH_VARARGS, "\n"
		"SoVRMLLOD_replaceChild(SoVRMLLOD self, int idx, SoNode child)\n"
		"SoVRMLLOD_replaceChild(SoVRMLLOD self, SoNode old, SoNode child)\n"
		""},
	 { "SoVRMLLOD_getChildren", _wrap_SoVRMLLOD_getChildren, METH_O, "SoVRMLLOD_getChildren(SoVRMLLOD self) -> SoChildList"},
	 { "SoVRMLLOD_swigregister", SoVRMLLOD_swigregister, METH_O, NULL},
	 { "SoVRMLLOD_swiginit", SoVRMLLOD_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLMaterial_getClassTypeId", _wrap_SoVRMLMaterial_getClassTypeId, METH_NOARGS, "SoVRMLMaterial_getClassTypeId() -> SoType"},
	 { "SoVRMLMaterial_getTypeId", _wrap_SoVRMLMaterial_getTypeId, METH_O, "SoVRMLMaterial_getTypeId(SoVRMLMaterial self) -> SoType"},
	 { "SoVRMLMaterial_initClass", _wrap_SoVRMLMaterial_initClass, METH_NOARGS, "SoVRMLMaterial_initClass()"},
	 { "new_SoVRMLMaterial", _wrap_new_SoVRMLMaterial, METH_NOARGS, "new_SoVRMLMaterial() -> SoVRMLMaterial"},
	 { "SoVRMLMaterial_diffuseColor_set", _wrap_SoVRMLMaterial_diffuseColor_set, METH_VARARGS, "SoVRMLMaterial_diffuseColor_set(SoVRMLMaterial self, SoSFColor diffuseColor)"},
	 { "SoVRMLMaterial_diffuseColor_get", _wrap_SoVRMLMaterial_diffuseColor_get, METH_O, "SoVRMLMaterial_diffuseColor_get(SoVRMLMaterial self) -> SoSFColor"},
	 { "SoVRMLMaterial_ambientIntensity_set", _wrap_SoVRMLMaterial_ambientIntensity_set, METH_VARARGS, "SoVRMLMaterial_ambientIntensity_set(SoVRMLMaterial self, SoSFFloat ambientIntensity)"},
	 { "SoVRMLMaterial_ambientIntensity_get", _wrap_SoVRMLMaterial_ambientIntensity_get, METH_O, "SoVRMLMaterial_ambientIntensity_get(SoVRMLMaterial self) -> SoSFFloat"},
	 { "SoVRMLMaterial_specularColor_set", _wrap_SoVRMLMaterial_specularColor_set, METH_VARARGS, "SoVRMLMaterial_specularColor_set(SoVRMLMaterial self, SoSFColor specularColor)"},
	 { "SoVRMLMaterial_specularColor_get", _wrap_SoVRMLMaterial_specularColor_get, METH_O, "SoVRMLMaterial_specularColor_get(SoVRMLMaterial self) -> SoSFColor"},
	 { "SoVRMLMaterial_emissiveColor_set", _wrap_SoVRMLMaterial_emissiveColor_set, METH_VARARGS, "SoVRMLMaterial_emissiveColor_set(SoVRMLMaterial self, SoSFColor emissiveColor)"},
	 { "SoVRMLMaterial_emissiveColor_get", _wrap_SoVRMLMaterial_emissiveColor_get, METH_O, "SoVRMLMaterial_emissiveColor_get(SoVRMLMaterial self) -> SoSFColor"},
	 { "SoVRMLMaterial_shininess_set", _wrap_SoVRMLMaterial_shininess_set, METH_VARARGS, "SoVRMLMaterial_shininess_set(SoVRMLMaterial self, SoSFFloat shininess)"},
	 { "SoVRMLMaterial_shininess_get", _wrap_SoVRMLMaterial_shininess_get, METH_O, "SoVRMLMaterial_shininess_get(SoVRMLMaterial self) -> SoSFFloat"},
	 { "SoVRMLMaterial_transparency_set", _wrap_SoVRMLMaterial_transparency_set, METH_VARARGS, "SoVRMLMaterial_transparency_set(SoVRMLMaterial self, SoSFFloat transparency)"},
	 { "SoVRMLMaterial_transparency_get", _wrap_SoVRMLMaterial_transparency_get, METH_O, "SoVRMLMaterial_transparency_get(SoVRMLMaterial self) -> SoSFFloat"},
	 { "SoVRMLMaterial_doAction", _wrap_SoVRMLMaterial_doAction, METH_VARARGS, "SoVRMLMaterial_doAction(SoVRMLMaterial self, SoAction action)"},
	 { "SoVRMLMaterial_GLRender", _wrap_SoVRMLMaterial_GLRender, METH_VARARGS, "SoVRMLMaterial_GLRender(SoVRMLMaterial self, SoGLRenderAction action)"},
	 { "SoVRMLMaterial_callback", _wrap_SoVRMLMaterial_callback, METH_VARARGS, "SoVRMLMaterial_callback(SoVRMLMaterial self, SoCallbackAction action)"},
	 { "SoVRMLMaterial_swigregister", SoVRMLMaterial_swigregister, METH_O, NULL},
	 { "SoVRMLMaterial_swiginit", SoVRMLMaterial_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLMovieTexture_getClassTypeId", _wrap_SoVRMLMovieTexture_getClassTypeId, METH_NOARGS, "SoVRMLMovieTexture_getClassTypeId() -> SoType"},
	 { "SoVRMLMovieTexture_getTypeId", _wrap_SoVRMLMovieTexture_getTypeId, METH_O, "SoVRMLMovieTexture_getTypeId(SoVRMLMovieTexture self) -> SoType"},
	 { "SoVRMLMovieTexture_initClass", _wrap_SoVRMLMovieTexture_initClass, METH_NOARGS, "SoVRMLMovieTexture_initClass()"},
	 { "new_SoVRMLMovieTexture", _wrap_new_SoVRMLMovieTexture, METH_NOARGS, "new_SoVRMLMovieTexture() -> SoVRMLMovieTexture"},
	 { "SoVRMLMovieTexture_loop_set", _wrap_SoVRMLMovieTexture_loop_set, METH_VARARGS, "SoVRMLMovieTexture_loop_set(SoVRMLMovieTexture self, SoSFBool loop)"},
	 { "SoVRMLMovieTexture_loop_get", _wrap_SoVRMLMovieTexture_loop_get, METH_O, "SoVRMLMovieTexture_loop_get(SoVRMLMovieTexture self) -> SoSFBool"},
	 { "SoVRMLMovieTexture_speed_set", _wrap_SoVRMLMovieTexture_speed_set, METH_VARARGS, "SoVRMLMovieTexture_speed_set(SoVRMLMovieTexture self, SoSFFloat speed)"},
	 { "SoVRMLMovieTexture_speed_get", _wrap_SoVRMLMovieTexture_speed_get, METH_O, "SoVRMLMovieTexture_speed_get(SoVRMLMovieTexture self) -> SoSFFloat"},
	 { "SoVRMLMovieTexture_startTime_set", _wrap_SoVRMLMovieTexture_startTime_set, METH_VARARGS, "SoVRMLMovieTexture_startTime_set(SoVRMLMovieTexture self, SoSFTime startTime)"},
	 { "SoVRMLMovieTexture_startTime_get", _wrap_SoVRMLMovieTexture_startTime_get, METH_O, "SoVRMLMovieTexture_startTime_get(SoVRMLMovieTexture self) -> SoSFTime"},
	 { "SoVRMLMovieTexture_stopTime_set", _wrap_SoVRMLMovieTexture_stopTime_set, METH_VARARGS, "SoVRMLMovieTexture_stopTime_set(SoVRMLMovieTexture self, SoSFTime stopTime)"},
	 { "SoVRMLMovieTexture_stopTime_get", _wrap_SoVRMLMovieTexture_stopTime_get, METH_O, "SoVRMLMovieTexture_stopTime_get(SoVRMLMovieTexture self) -> SoSFTime"},
	 { "SoVRMLMovieTexture_pauseTime_set", _wrap_SoVRMLMovieTexture_pauseTime_set, METH_VARARGS, "SoVRMLMovieTexture_pauseTime_set(SoVRMLMovieTexture self, SoSFTime pauseTime)"},
	 { "SoVRMLMovieTexture_pauseTime_get", _wrap_SoVRMLMovieTexture_pauseTime_get, METH_O, "SoVRMLMovieTexture_pauseTime_get(SoVRMLMovieTexture self) -> SoSFTime"},
	 { "SoVRMLMovieTexture_resumeTime_set", _wrap_SoVRMLMovieTexture_resumeTime_set, METH_VARARGS, "SoVRMLMovieTexture_resumeTime_set(SoVRMLMovieTexture self, SoSFTime resumeTime)"},
	 { "SoVRMLMovieTexture_resumeTime_get", _wrap_SoVRMLMovieTexture_resumeTime_get, METH_O, "SoVRMLMovieTexture_resumeTime_get(SoVRMLMovieTexture self) -> SoSFTime"},
	 { "SoVRMLMovieTexture_url_set", _wrap_SoVRMLMovieTexture_url_set, METH_VARARGS, "SoVRMLMovieTexture_url_set(SoVRMLMovieTexture self, SoMFString url)"},
	 { "SoVRMLMovieTexture_url_get", _wrap_SoVRMLMovieTexture_url_get, METH_O, "SoVRMLMovieTexture_url_get(SoVRMLMovieTexture self) -> SoMFString"},
	 { "SoVRMLMovieTexture_duration_changed_set", _wrap_SoVRMLMovieTexture_duration_changed_set, METH_VARARGS, "SoVRMLMovieTexture_duration_changed_set(SoVRMLMovieTexture self, SoSFTime duration_changed)"},
	 { "SoVRMLMovieTexture_duration_changed_get", _wrap_SoVRMLMovieTexture_duration_changed_get, METH_O, "SoVRMLMovieTexture_duration_changed_get(SoVRMLMovieTexture self) -> SoSFTime"},
	 { "SoVRMLMovieTexture_isActive_set", _wrap_SoVRMLMovieTexture_isActive_set, METH_VARARGS, "SoVRMLMovieTexture_isActive_set(SoVRMLMovieTexture self, SoSFBool isActive)"},
	 { "SoVRMLMovieTexture_isActive_get", _wrap_SoVRMLMovieTexture_isActive_get, METH_O, "SoVRMLMovieTexture_isActive_get(SoVRMLMovieTexture self) -> SoSFBool"},
	 { "SoVRMLMovieTexture_alpha_set", _wrap_SoVRMLMovieTexture_alpha_set, METH_VARARGS, "SoVRMLMovieTexture_alpha_set(SoVRMLMovieTexture self, SoSFFloat alpha)"},
	 { "SoVRMLMovieTexture_alpha_get", _wrap_SoVRMLMovieTexture_alpha_get, METH_O, "SoVRMLMovieTexture_alpha_get(SoVRMLMovieTexture self) -> SoSFFloat"},
	 { "SoVRMLMovieTexture_model_set", _wrap_SoVRMLMovieTexture_model_set, METH_VARARGS, "SoVRMLMovieTexture_model_set(SoVRMLMovieTexture self, SoSFEnum model)"},
	 { "SoVRMLMovieTexture_model_get", _wrap_SoVRMLMovieTexture_model_get, METH_O, "SoVRMLMovieTexture_model_get(SoVRMLMovieTexture self) -> SoSFEnum"},
	 { "SoVRMLMovieTexture_blendColor_set", _wrap_SoVRMLMovieTexture_blendColor_set, METH_VARARGS, "SoVRMLMovieTexture_blendColor_set(SoVRMLMovieTexture self, SoSFColor blendColor)"},
	 { "SoVRMLMovieTexture_blendColor_get", _wrap_SoVRMLMovieTexture_blendColor_get, METH_O, "SoVRMLMovieTexture_blendColor_get(SoVRMLMovieTexture self) -> SoSFColor"},
	 { "SoVRMLMovieTexture_scaleTexCoord_set", _wrap_SoVRMLMovieTexture_scaleTexCoord_set, METH_VARARGS, "SoVRMLMovieTexture_scaleTexCoord_set(SoVRMLMovieTexture self, SoSFBool scaleTexCoord)"},
	 { "SoVRMLMovieTexture_scaleTexCoord_get", _wrap_SoVRMLMovieTexture_scaleTexCoord_get, METH_O, "SoVRMLMovieTexture_scaleTexCoord_get(SoVRMLMovieTexture self) -> SoSFBool"},
	 { "SoVRMLMovieTexture_GLRender", _wrap_SoVRMLMovieTexture_GLRender, METH_VARARGS, "SoVRMLMovieTexture_GLRender(SoVRMLMovieTexture self, SoGLRenderAction action)"},
	 { "SoVRMLMovieTexture_swigregister", SoVRMLMovieTexture_swigregister, METH_O, NULL},
	 { "SoVRMLMovieTexture_swiginit", SoVRMLMovieTexture_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLNavigationInfo_getClassTypeId", _wrap_SoVRMLNavigationInfo_getClassTypeId, METH_NOARGS, "SoVRMLNavigationInfo_getClassTypeId() -> SoType"},
	 { "SoVRMLNavigationInfo_getTypeId", _wrap_SoVRMLNavigationInfo_getTypeId, METH_O, "SoVRMLNavigationInfo_getTypeId(SoVRMLNavigationInfo self) -> SoType"},
	 { "SoVRMLNavigationInfo_initClass", _wrap_SoVRMLNavigationInfo_initClass, METH_NOARGS, "SoVRMLNavigationInfo_initClass()"},
	 { "new_SoVRMLNavigationInfo", _wrap_new_SoVRMLNavigationInfo, METH_NOARGS, "new_SoVRMLNavigationInfo() -> SoVRMLNavigationInfo"},
	 { "SoVRMLNavigationInfo_type_set", _wrap_SoVRMLNavigationInfo_type_set, METH_VARARGS, "SoVRMLNavigationInfo_type_set(SoVRMLNavigationInfo self, SoMFString type)"},
	 { "SoVRMLNavigationInfo_type_get", _wrap_SoVRMLNavigationInfo_type_get, METH_O, "SoVRMLNavigationInfo_type_get(SoVRMLNavigationInfo self) -> SoMFString"},
	 { "SoVRMLNavigationInfo_speed_set", _wrap_SoVRMLNavigationInfo_speed_set, METH_VARARGS, "SoVRMLNavigationInfo_speed_set(SoVRMLNavigationInfo self, SoSFFloat speed)"},
	 { "SoVRMLNavigationInfo_speed_get", _wrap_SoVRMLNavigationInfo_speed_get, METH_O, "SoVRMLNavigationInfo_speed_get(SoVRMLNavigationInfo self) -> SoSFFloat"},
	 { "SoVRMLNavigationInfo_avatarSize_set", _wrap_SoVRMLNavigationInfo_avatarSize_set, METH_VARARGS, "SoVRMLNavigationInfo_avatarSize_set(SoVRMLNavigationInfo self, SoMFFloat avatarSize)"},
	 { "SoVRMLNavigationInfo_avatarSize_get", _wrap_SoVRMLNavigationInfo_avatarSize_get, METH_O, "SoVRMLNavigationInfo_avatarSize_get(SoVRMLNavigationInfo self) -> SoMFFloat"},
	 { "SoVRMLNavigationInfo_visibilityLimit_set", _wrap_SoVRMLNavigationInfo_visibilityLimit_set, METH_VARARGS, "SoVRMLNavigationInfo_visibilityLimit_set(SoVRMLNavigationInfo self, SoSFFloat visibilityLimit)"},
	 { "SoVRMLNavigationInfo_visibilityLimit_get", _wrap_SoVRMLNavigationInfo_visibilityLimit_get, METH_O, "SoVRMLNavigationInfo_visibilityLimit_get(SoVRMLNavigationInfo self) -> SoSFFloat"},
	 { "SoVRMLNavigationInfo_headlight_set", _wrap_SoVRMLNavigationInfo_headlight_set, METH_VARARGS, "SoVRMLNavigationInfo_headlight_set(SoVRMLNavigationInfo self, SoSFBool headlight)"},
	 { "SoVRMLNavigationInfo_headlight_get", _wrap_SoVRMLNavigationInfo_headlight_get, METH_O, "SoVRMLNavigationInfo_headlight_get(SoVRMLNavigationInfo self) -> SoSFBool"},
	 { "SoVRMLNavigationInfo_GLRender", _wrap_SoVRMLNavigationInfo_GLRender, METH_VARARGS, "SoVRMLNavigationInfo_GLRender(SoVRMLNavigationInfo self, SoGLRenderAction action)"},
	 { "SoVRMLNavigationInfo_swigregister", SoVRMLNavigationInfo_swigregister, METH_O, NULL},
	 { "SoVRMLNavigationInfo_swiginit", SoVRMLNavigationInfo_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLNormal_getClassTypeId", _wrap_SoVRMLNormal_getClassTypeId, METH_NOARGS, "SoVRMLNormal_getClassTypeId() -> SoType"},
	 { "SoVRMLNormal_getTypeId", _wrap_SoVRMLNormal_getTypeId, METH_O, "SoVRMLNormal_getTypeId(SoVRMLNormal self) -> SoType"},
	 { "SoVRMLNormal_initClass", _wrap_SoVRMLNormal_initClass, METH_NOARGS, "SoVRMLNormal_initClass()"},
	 { "new_SoVRMLNormal", _wrap_new_SoVRMLNormal, METH_NOARGS, "new_SoVRMLNormal() -> SoVRMLNormal"},
	 { "SoVRMLNormal_vector_set", _wrap_SoVRMLNormal_vector_set, METH_VARARGS, "SoVRMLNormal_vector_set(SoVRMLNormal self, SoMFVec3f vector)"},
	 { "SoVRMLNormal_vector_get", _wrap_SoVRMLNormal_vector_get, METH_O, "SoVRMLNormal_vector_get(SoVRMLNormal self) -> SoMFVec3f"},
	 { "SoVRMLNormal_doAction", _wrap_SoVRMLNormal_doAction, METH_VARARGS, "SoVRMLNormal_doAction(SoVRMLNormal self, SoAction action)"},
	 { "SoVRMLNormal_GLRender", _wrap_SoVRMLNormal_GLRender, METH_VARARGS, "SoVRMLNormal_GLRender(SoVRMLNormal self, SoGLRenderAction action)"},
	 { "SoVRMLNormal_callback", _wrap_SoVRMLNormal_callback, METH_VARARGS, "SoVRMLNormal_callback(SoVRMLNormal self, SoCallbackAction action)"},
	 { "SoVRMLNormal_pick", _wrap_SoVRMLNormal_pick, METH_VARARGS, "SoVRMLNormal_pick(SoVRMLNormal self, SoPickAction action)"},
	 { "SoVRMLNormal_getPrimitiveCount", _wrap_SoVRMLNormal_getPrimitiveCount, METH_VARARGS, "SoVRMLNormal_getPrimitiveCount(SoVRMLNormal self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLNormal_swigregister", SoVRMLNormal_swigregister, METH_O, NULL},
	 { "SoVRMLNormal_swiginit", SoVRMLNormal_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLNormalInterpolator_getClassTypeId", _wrap_SoVRMLNormalInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLNormalInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLNormalInterpolator_getTypeId", _wrap_SoVRMLNormalInterpolator_getTypeId, METH_O, "SoVRMLNormalInterpolator_getTypeId(SoVRMLNormalInterpolator self) -> SoType"},
	 { "SoVRMLNormalInterpolator_getOutputData", _wrap_SoVRMLNormalInterpolator_getOutputData, METH_O, "SoVRMLNormalInterpolator_getOutputData(SoVRMLNormalInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLNormalInterpolator_createInstance", _wrap_SoVRMLNormalInterpolator_createInstance, METH_NOARGS, "SoVRMLNormalInterpolator_createInstance() -> void *"},
	 { "SoVRMLNormalInterpolator_initClass", _wrap_SoVRMLNormalInterpolator_initClass, METH_NOARGS, "SoVRMLNormalInterpolator_initClass()"},
	 { "new_SoVRMLNormalInterpolator", _wrap_new_SoVRMLNormalInterpolator, METH_NOARGS, "new_SoVRMLNormalInterpolator() -> SoVRMLNormalInterpolator"},
	 { "SoVRMLNormalInterpolator_keyValue_set", _wrap_SoVRMLNormalInterpolator_keyValue_set, METH_VARARGS, "SoVRMLNormalInterpolator_keyValue_set(SoVRMLNormalInterpolator self, SoMFVec3f keyValue)"},
	 { "SoVRMLNormalInterpolator_keyValue_get", _wrap_SoVRMLNormalInterpolator_keyValue_get, METH_O, "SoVRMLNormalInterpolator_keyValue_get(SoVRMLNormalInterpolator self) -> SoMFVec3f"},
	 { "SoVRMLNormalInterpolator_value_changed_set", _wrap_SoVRMLNormalInterpolator_value_changed_set, METH_VARARGS, "SoVRMLNormalInterpolator_value_changed_set(SoVRMLNormalInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLNormalInterpolator_value_changed_get", _wrap_SoVRMLNormalInterpolator_value_changed_get, METH_O, "SoVRMLNormalInterpolator_value_changed_get(SoVRMLNormalInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLNormalInterpolator_swigregister", SoVRMLNormalInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLNormalInterpolator_swiginit", SoVRMLNormalInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLOrientationInterpolator_getClassTypeId", _wrap_SoVRMLOrientationInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLOrientationInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLOrientationInterpolator_getTypeId", _wrap_SoVRMLOrientationInterpolator_getTypeId, METH_O, "SoVRMLOrientationInterpolator_getTypeId(SoVRMLOrientationInterpolator self) -> SoType"},
	 { "SoVRMLOrientationInterpolator_getOutputData", _wrap_SoVRMLOrientationInterpolator_getOutputData, METH_O, "SoVRMLOrientationInterpolator_getOutputData(SoVRMLOrientationInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLOrientationInterpolator_createInstance", _wrap_SoVRMLOrientationInterpolator_createInstance, METH_NOARGS, "SoVRMLOrientationInterpolator_createInstance() -> void *"},
	 { "SoVRMLOrientationInterpolator_initClass", _wrap_SoVRMLOrientationInterpolator_initClass, METH_NOARGS, "SoVRMLOrientationInterpolator_initClass()"},
	 { "new_SoVRMLOrientationInterpolator", _wrap_new_SoVRMLOrientationInterpolator, METH_NOARGS, "new_SoVRMLOrientationInterpolator() -> SoVRMLOrientationInterpolator"},
	 { "SoVRMLOrientationInterpolator_keyValue_set", _wrap_SoVRMLOrientationInterpolator_keyValue_set, METH_VARARGS, "SoVRMLOrientationInterpolator_keyValue_set(SoVRMLOrientationInterpolator self, SoMFRotation keyValue)"},
	 { "SoVRMLOrientationInterpolator_keyValue_get", _wrap_SoVRMLOrientationInterpolator_keyValue_get, METH_O, "SoVRMLOrientationInterpolator_keyValue_get(SoVRMLOrientationInterpolator self) -> SoMFRotation"},
	 { "SoVRMLOrientationInterpolator_value_changed_set", _wrap_SoVRMLOrientationInterpolator_value_changed_set, METH_VARARGS, "SoVRMLOrientationInterpolator_value_changed_set(SoVRMLOrientationInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLOrientationInterpolator_value_changed_get", _wrap_SoVRMLOrientationInterpolator_value_changed_get, METH_O, "SoVRMLOrientationInterpolator_value_changed_get(SoVRMLOrientationInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLOrientationInterpolator_swigregister", SoVRMLOrientationInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLOrientationInterpolator_swiginit", SoVRMLOrientationInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLPixelTexture_getClassTypeId", _wrap_SoVRMLPixelTexture_getClassTypeId, METH_NOARGS, "SoVRMLPixelTexture_getClassTypeId() -> SoType"},
	 { "SoVRMLPixelTexture_getTypeId", _wrap_SoVRMLPixelTexture_getTypeId, METH_O, "SoVRMLPixelTexture_getTypeId(SoVRMLPixelTexture self) -> SoType"},
	 { "SoVRMLPixelTexture_initClass", _wrap_SoVRMLPixelTexture_initClass, METH_NOARGS, "SoVRMLPixelTexture_initClass()"},
	 { "new_SoVRMLPixelTexture", _wrap_new_SoVRMLPixelTexture, METH_NOARGS, "new_SoVRMLPixelTexture() -> SoVRMLPixelTexture"},
	 { "SoVRMLPixelTexture_image_set", _wrap_SoVRMLPixelTexture_image_set, METH_VARARGS, "SoVRMLPixelTexture_image_set(SoVRMLPixelTexture self, SoSFImage image)"},
	 { "SoVRMLPixelTexture_image_get", _wrap_SoVRMLPixelTexture_image_get, METH_O, "SoVRMLPixelTexture_image_get(SoVRMLPixelTexture self) -> SoSFImage"},
	 { "SoVRMLPixelTexture_doAction", _wrap_SoVRMLPixelTexture_doAction, METH_VARARGS, "SoVRMLPixelTexture_doAction(SoVRMLPixelTexture self, SoAction action)"},
	 { "SoVRMLPixelTexture_GLRender", _wrap_SoVRMLPixelTexture_GLRender, METH_VARARGS, "SoVRMLPixelTexture_GLRender(SoVRMLPixelTexture self, SoGLRenderAction action)"},
	 { "SoVRMLPixelTexture_callback", _wrap_SoVRMLPixelTexture_callback, METH_VARARGS, "SoVRMLPixelTexture_callback(SoVRMLPixelTexture self, SoCallbackAction action)"},
	 { "SoVRMLPixelTexture_rayPick", _wrap_SoVRMLPixelTexture_rayPick, METH_VARARGS, "SoVRMLPixelTexture_rayPick(SoVRMLPixelTexture self, SoRayPickAction action)"},
	 { "SoVRMLPixelTexture_swigregister", SoVRMLPixelTexture_swigregister, METH_O, NULL},
	 { "SoVRMLPixelTexture_swiginit", SoVRMLPixelTexture_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLPlaneSensor_getClassTypeId", _wrap_SoVRMLPlaneSensor_getClassTypeId, METH_NOARGS, "SoVRMLPlaneSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLPlaneSensor_getTypeId", _wrap_SoVRMLPlaneSensor_getTypeId, METH_O, "SoVRMLPlaneSensor_getTypeId(SoVRMLPlaneSensor self) -> SoType"},
	 { "SoVRMLPlaneSensor_initClass", _wrap_SoVRMLPlaneSensor_initClass, METH_NOARGS, "SoVRMLPlaneSensor_initClass()"},
	 { "new_SoVRMLPlaneSensor", _wrap_new_SoVRMLPlaneSensor, METH_NOARGS, "new_SoVRMLPlaneSensor() -> SoVRMLPlaneSensor"},
	 { "SoVRMLPlaneSensor_minPosition_set", _wrap_SoVRMLPlaneSensor_minPosition_set, METH_VARARGS, "SoVRMLPlaneSensor_minPosition_set(SoVRMLPlaneSensor self, SoSFVec2f minPosition)"},
	 { "SoVRMLPlaneSensor_minPosition_get", _wrap_SoVRMLPlaneSensor_minPosition_get, METH_O, "SoVRMLPlaneSensor_minPosition_get(SoVRMLPlaneSensor self) -> SoSFVec2f"},
	 { "SoVRMLPlaneSensor_maxPosition_set", _wrap_SoVRMLPlaneSensor_maxPosition_set, METH_VARARGS, "SoVRMLPlaneSensor_maxPosition_set(SoVRMLPlaneSensor self, SoSFVec2f maxPosition)"},
	 { "SoVRMLPlaneSensor_maxPosition_get", _wrap_SoVRMLPlaneSensor_maxPosition_get, METH_O, "SoVRMLPlaneSensor_maxPosition_get(SoVRMLPlaneSensor self) -> SoSFVec2f"},
	 { "SoVRMLPlaneSensor_offset_set", _wrap_SoVRMLPlaneSensor_offset_set, METH_VARARGS, "SoVRMLPlaneSensor_offset_set(SoVRMLPlaneSensor self, SoSFVec3f offset)"},
	 { "SoVRMLPlaneSensor_offset_get", _wrap_SoVRMLPlaneSensor_offset_get, METH_O, "SoVRMLPlaneSensor_offset_get(SoVRMLPlaneSensor self) -> SoSFVec3f"},
	 { "SoVRMLPlaneSensor_translation_changed_set", _wrap_SoVRMLPlaneSensor_translation_changed_set, METH_VARARGS, "SoVRMLPlaneSensor_translation_changed_set(SoVRMLPlaneSensor self, SoSFVec3f translation_changed)"},
	 { "SoVRMLPlaneSensor_translation_changed_get", _wrap_SoVRMLPlaneSensor_translation_changed_get, METH_O, "SoVRMLPlaneSensor_translation_changed_get(SoVRMLPlaneSensor self) -> SoSFVec3f"},
	 { "SoVRMLPlaneSensor_swigregister", SoVRMLPlaneSensor_swigregister, METH_O, NULL},
	 { "SoVRMLPlaneSensor_swiginit", SoVRMLPlaneSensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLPointLight_getClassTypeId", _wrap_SoVRMLPointLight_getClassTypeId, METH_NOARGS, "SoVRMLPointLight_getClassTypeId() -> SoType"},
	 { "SoVRMLPointLight_getTypeId", _wrap_SoVRMLPointLight_getTypeId, METH_O, "SoVRMLPointLight_getTypeId(SoVRMLPointLight self) -> SoType"},
	 { "SoVRMLPointLight_initClass", _wrap_SoVRMLPointLight_initClass, METH_NOARGS, "SoVRMLPointLight_initClass()"},
	 { "new_SoVRMLPointLight", _wrap_new_SoVRMLPointLight, METH_NOARGS, "new_SoVRMLPointLight() -> SoVRMLPointLight"},
	 { "SoVRMLPointLight_location_set", _wrap_SoVRMLPointLight_location_set, METH_VARARGS, "SoVRMLPointLight_location_set(SoVRMLPointLight self, SoSFVec3f location)"},
	 { "SoVRMLPointLight_location_get", _wrap_SoVRMLPointLight_location_get, METH_O, "SoVRMLPointLight_location_get(SoVRMLPointLight self) -> SoSFVec3f"},
	 { "SoVRMLPointLight_radius_set", _wrap_SoVRMLPointLight_radius_set, METH_VARARGS, "SoVRMLPointLight_radius_set(SoVRMLPointLight self, SoSFFloat radius)"},
	 { "SoVRMLPointLight_radius_get", _wrap_SoVRMLPointLight_radius_get, METH_O, "SoVRMLPointLight_radius_get(SoVRMLPointLight self) -> SoSFFloat"},
	 { "SoVRMLPointLight_attenuation_set", _wrap_SoVRMLPointLight_attenuation_set, METH_VARARGS, "SoVRMLPointLight_attenuation_set(SoVRMLPointLight self, SoSFVec3f attenuation)"},
	 { "SoVRMLPointLight_attenuation_get", _wrap_SoVRMLPointLight_attenuation_get, METH_O, "SoVRMLPointLight_attenuation_get(SoVRMLPointLight self) -> SoSFVec3f"},
	 { "SoVRMLPointLight_GLRender", _wrap_SoVRMLPointLight_GLRender, METH_VARARGS, "SoVRMLPointLight_GLRender(SoVRMLPointLight self, SoGLRenderAction action)"},
	 { "SoVRMLPointLight_swigregister", SoVRMLPointLight_swigregister, METH_O, NULL},
	 { "SoVRMLPointLight_swiginit", SoVRMLPointLight_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLVertexPoint_getClassTypeId", _wrap_SoVRMLVertexPoint_getClassTypeId, METH_NOARGS, "SoVRMLVertexPoint_getClassTypeId() -> SoType"},
	 { "SoVRMLVertexPoint_getTypeId", _wrap_SoVRMLVertexPoint_getTypeId, METH_O, "SoVRMLVertexPoint_getTypeId(SoVRMLVertexPoint self) -> SoType"},
	 { "SoVRMLVertexPoint_initClass", _wrap_SoVRMLVertexPoint_initClass, METH_NOARGS, "SoVRMLVertexPoint_initClass()"},
	 { "SoVRMLVertexPoint_coord_set", _wrap_SoVRMLVertexPoint_coord_set, METH_VARARGS, "SoVRMLVertexPoint_coord_set(SoVRMLVertexPoint self, SoSFNode coord)"},
	 { "SoVRMLVertexPoint_coord_get", _wrap_SoVRMLVertexPoint_coord_get, METH_O, "SoVRMLVertexPoint_coord_get(SoVRMLVertexPoint self) -> SoSFNode"},
	 { "SoVRMLVertexPoint_color_set", _wrap_SoVRMLVertexPoint_color_set, METH_VARARGS, "SoVRMLVertexPoint_color_set(SoVRMLVertexPoint self, SoSFNode color)"},
	 { "SoVRMLVertexPoint_color_get", _wrap_SoVRMLVertexPoint_color_get, METH_O, "SoVRMLVertexPoint_color_get(SoVRMLVertexPoint self) -> SoSFNode"},
	 { "SoVRMLVertexPoint_doAction", _wrap_SoVRMLVertexPoint_doAction, METH_VARARGS, "SoVRMLVertexPoint_doAction(SoVRMLVertexPoint self, SoAction action)"},
	 { "SoVRMLVertexPoint_GLRender", _wrap_SoVRMLVertexPoint_GLRender, METH_VARARGS, "SoVRMLVertexPoint_GLRender(SoVRMLVertexPoint self, SoGLRenderAction action)"},
	 { "SoVRMLVertexPoint_getBoundingBox", _wrap_SoVRMLVertexPoint_getBoundingBox, METH_VARARGS, "SoVRMLVertexPoint_getBoundingBox(SoVRMLVertexPoint self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLVertexPoint_callback", _wrap_SoVRMLVertexPoint_callback, METH_VARARGS, "SoVRMLVertexPoint_callback(SoVRMLVertexPoint self, SoCallbackAction action)"},
	 { "SoVRMLVertexPoint_pick", _wrap_SoVRMLVertexPoint_pick, METH_VARARGS, "SoVRMLVertexPoint_pick(SoVRMLVertexPoint self, SoPickAction action)"},
	 { "SoVRMLVertexPoint_getPrimitiveCount", _wrap_SoVRMLVertexPoint_getPrimitiveCount, METH_VARARGS, "SoVRMLVertexPoint_getPrimitiveCount(SoVRMLVertexPoint self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLVertexPoint_notify", _wrap_SoVRMLVertexPoint_notify, METH_VARARGS, "SoVRMLVertexPoint_notify(SoVRMLVertexPoint self, SoNotList list)"},
	 { "SoVRMLVertexPoint_swigregister", SoVRMLVertexPoint_swigregister, METH_O, NULL},
	 { "SoVRMLPointSet_getClassTypeId", _wrap_SoVRMLPointSet_getClassTypeId, METH_NOARGS, "SoVRMLPointSet_getClassTypeId() -> SoType"},
	 { "SoVRMLPointSet_getTypeId", _wrap_SoVRMLPointSet_getTypeId, METH_O, "SoVRMLPointSet_getTypeId(SoVRMLPointSet self) -> SoType"},
	 { "SoVRMLPointSet_initClass", _wrap_SoVRMLPointSet_initClass, METH_NOARGS, "SoVRMLPointSet_initClass()"},
	 { "new_SoVRMLPointSet", _wrap_new_SoVRMLPointSet, METH_NOARGS, "new_SoVRMLPointSet() -> SoVRMLPointSet"},
	 { "SoVRMLPointSet_GLRender", _wrap_SoVRMLPointSet_GLRender, METH_VARARGS, "SoVRMLPointSet_GLRender(SoVRMLPointSet self, SoGLRenderAction action)"},
	 { "SoVRMLPointSet_getBoundingBox", _wrap_SoVRMLPointSet_getBoundingBox, METH_VARARGS, "SoVRMLPointSet_getBoundingBox(SoVRMLPointSet self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLPointSet_swigregister", SoVRMLPointSet_swigregister, METH_O, NULL},
	 { "SoVRMLPointSet_swiginit", SoVRMLPointSet_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLPositionInterpolator_getClassTypeId", _wrap_SoVRMLPositionInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLPositionInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLPositionInterpolator_getTypeId", _wrap_SoVRMLPositionInterpolator_getTypeId, METH_O, "SoVRMLPositionInterpolator_getTypeId(SoVRMLPositionInterpolator self) -> SoType"},
	 { "SoVRMLPositionInterpolator_getOutputData", _wrap_SoVRMLPositionInterpolator_getOutputData, METH_O, "SoVRMLPositionInterpolator_getOutputData(SoVRMLPositionInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLPositionInterpolator_createInstance", _wrap_SoVRMLPositionInterpolator_createInstance, METH_NOARGS, "SoVRMLPositionInterpolator_createInstance() -> void *"},
	 { "SoVRMLPositionInterpolator_initClass", _wrap_SoVRMLPositionInterpolator_initClass, METH_NOARGS, "SoVRMLPositionInterpolator_initClass()"},
	 { "new_SoVRMLPositionInterpolator", _wrap_new_SoVRMLPositionInterpolator, METH_NOARGS, "new_SoVRMLPositionInterpolator() -> SoVRMLPositionInterpolator"},
	 { "SoVRMLPositionInterpolator_keyValue_set", _wrap_SoVRMLPositionInterpolator_keyValue_set, METH_VARARGS, "SoVRMLPositionInterpolator_keyValue_set(SoVRMLPositionInterpolator self, SoMFVec3f keyValue)"},
	 { "SoVRMLPositionInterpolator_keyValue_get", _wrap_SoVRMLPositionInterpolator_keyValue_get, METH_O, "SoVRMLPositionInterpolator_keyValue_get(SoVRMLPositionInterpolator self) -> SoMFVec3f"},
	 { "SoVRMLPositionInterpolator_value_changed_set", _wrap_SoVRMLPositionInterpolator_value_changed_set, METH_VARARGS, "SoVRMLPositionInterpolator_value_changed_set(SoVRMLPositionInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLPositionInterpolator_value_changed_get", _wrap_SoVRMLPositionInterpolator_value_changed_get, METH_O, "SoVRMLPositionInterpolator_value_changed_get(SoVRMLPositionInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLPositionInterpolator_swigregister", SoVRMLPositionInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLPositionInterpolator_swiginit", SoVRMLPositionInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLProximitySensor_getClassTypeId", _wrap_SoVRMLProximitySensor_getClassTypeId, METH_NOARGS, "SoVRMLProximitySensor_getClassTypeId() -> SoType"},
	 { "SoVRMLProximitySensor_getTypeId", _wrap_SoVRMLProximitySensor_getTypeId, METH_O, "SoVRMLProximitySensor_getTypeId(SoVRMLProximitySensor self) -> SoType"},
	 { "SoVRMLProximitySensor_initClass", _wrap_SoVRMLProximitySensor_initClass, METH_NOARGS, "SoVRMLProximitySensor_initClass()"},
	 { "new_SoVRMLProximitySensor", _wrap_new_SoVRMLProximitySensor, METH_NOARGS, "new_SoVRMLProximitySensor() -> SoVRMLProximitySensor"},
	 { "SoVRMLProximitySensor_center_set", _wrap_SoVRMLProximitySensor_center_set, METH_VARARGS, "SoVRMLProximitySensor_center_set(SoVRMLProximitySensor self, SoSFVec3f center)"},
	 { "SoVRMLProximitySensor_center_get", _wrap_SoVRMLProximitySensor_center_get, METH_O, "SoVRMLProximitySensor_center_get(SoVRMLProximitySensor self) -> SoSFVec3f"},
	 { "SoVRMLProximitySensor_size_set", _wrap_SoVRMLProximitySensor_size_set, METH_VARARGS, "SoVRMLProximitySensor_size_set(SoVRMLProximitySensor self, SoSFVec3f size)"},
	 { "SoVRMLProximitySensor_size_get", _wrap_SoVRMLProximitySensor_size_get, METH_O, "SoVRMLProximitySensor_size_get(SoVRMLProximitySensor self) -> SoSFVec3f"},
	 { "SoVRMLProximitySensor_enabled_set", _wrap_SoVRMLProximitySensor_enabled_set, METH_VARARGS, "SoVRMLProximitySensor_enabled_set(SoVRMLProximitySensor self, SoSFBool enabled)"},
	 { "SoVRMLProximitySensor_enabled_get", _wrap_SoVRMLProximitySensor_enabled_get, METH_O, "SoVRMLProximitySensor_enabled_get(SoVRMLProximitySensor self) -> SoSFBool"},
	 { "SoVRMLProximitySensor_isActive_set", _wrap_SoVRMLProximitySensor_isActive_set, METH_VARARGS, "SoVRMLProximitySensor_isActive_set(SoVRMLProximitySensor self, SoSFBool isActive)"},
	 { "SoVRMLProximitySensor_isActive_get", _wrap_SoVRMLProximitySensor_isActive_get, METH_O, "SoVRMLProximitySensor_isActive_get(SoVRMLProximitySensor self) -> SoSFBool"},
	 { "SoVRMLProximitySensor_position_changed_set", _wrap_SoVRMLProximitySensor_position_changed_set, METH_VARARGS, "SoVRMLProximitySensor_position_changed_set(SoVRMLProximitySensor self, SoSFVec3f position_changed)"},
	 { "SoVRMLProximitySensor_position_changed_get", _wrap_SoVRMLProximitySensor_position_changed_get, METH_O, "SoVRMLProximitySensor_position_changed_get(SoVRMLProximitySensor self) -> SoSFVec3f"},
	 { "SoVRMLProximitySensor_orientation_changed_set", _wrap_SoVRMLProximitySensor_orientation_changed_set, METH_VARARGS, "SoVRMLProximitySensor_orientation_changed_set(SoVRMLProximitySensor self, SoSFRotation orientation_changed)"},
	 { "SoVRMLProximitySensor_orientation_changed_get", _wrap_SoVRMLProximitySensor_orientation_changed_get, METH_O, "SoVRMLProximitySensor_orientation_changed_get(SoVRMLProximitySensor self) -> SoSFRotation"},
	 { "SoVRMLProximitySensor_enterTime_set", _wrap_SoVRMLProximitySensor_enterTime_set, METH_VARARGS, "SoVRMLProximitySensor_enterTime_set(SoVRMLProximitySensor self, SoSFTime enterTime)"},
	 { "SoVRMLProximitySensor_enterTime_get", _wrap_SoVRMLProximitySensor_enterTime_get, METH_O, "SoVRMLProximitySensor_enterTime_get(SoVRMLProximitySensor self) -> SoSFTime"},
	 { "SoVRMLProximitySensor_exitTime_set", _wrap_SoVRMLProximitySensor_exitTime_set, METH_VARARGS, "SoVRMLProximitySensor_exitTime_set(SoVRMLProximitySensor self, SoSFTime exitTime)"},
	 { "SoVRMLProximitySensor_exitTime_get", _wrap_SoVRMLProximitySensor_exitTime_get, METH_O, "SoVRMLProximitySensor_exitTime_get(SoVRMLProximitySensor self) -> SoSFTime"},
	 { "SoVRMLProximitySensor_affectsState", _wrap_SoVRMLProximitySensor_affectsState, METH_O, "SoVRMLProximitySensor_affectsState(SoVRMLProximitySensor self) -> SbBool"},
	 { "SoVRMLProximitySensor_doAction", _wrap_SoVRMLProximitySensor_doAction, METH_VARARGS, "SoVRMLProximitySensor_doAction(SoVRMLProximitySensor self, SoAction action)"},
	 { "SoVRMLProximitySensor_GLRender", _wrap_SoVRMLProximitySensor_GLRender, METH_VARARGS, "SoVRMLProximitySensor_GLRender(SoVRMLProximitySensor self, SoGLRenderAction action)"},
	 { "SoVRMLProximitySensor_callback", _wrap_SoVRMLProximitySensor_callback, METH_VARARGS, "SoVRMLProximitySensor_callback(SoVRMLProximitySensor self, SoCallbackAction action)"},
	 { "SoVRMLProximitySensor_rayPick", _wrap_SoVRMLProximitySensor_rayPick, METH_VARARGS, "SoVRMLProximitySensor_rayPick(SoVRMLProximitySensor self, SoRayPickAction action)"},
	 { "SoVRMLProximitySensor_getBoundingBox", _wrap_SoVRMLProximitySensor_getBoundingBox, METH_VARARGS, "SoVRMLProximitySensor_getBoundingBox(SoVRMLProximitySensor self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLProximitySensor_swigregister", SoVRMLProximitySensor_swigregister, METH_O, NULL},
	 { "SoVRMLProximitySensor_swiginit", SoVRMLProximitySensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLScalarInterpolator_getClassTypeId", _wrap_SoVRMLScalarInterpolator_getClassTypeId, METH_NOARGS, "SoVRMLScalarInterpolator_getClassTypeId() -> SoType"},
	 { "SoVRMLScalarInterpolator_getTypeId", _wrap_SoVRMLScalarInterpolator_getTypeId, METH_O, "SoVRMLScalarInterpolator_getTypeId(SoVRMLScalarInterpolator self) -> SoType"},
	 { "SoVRMLScalarInterpolator_getOutputData", _wrap_SoVRMLScalarInterpolator_getOutputData, METH_O, "SoVRMLScalarInterpolator_getOutputData(SoVRMLScalarInterpolator self) -> SoEngineOutputData"},
	 { "SoVRMLScalarInterpolator_createInstance", _wrap_SoVRMLScalarInterpolator_createInstance, METH_NOARGS, "SoVRMLScalarInterpolator_createInstance() -> void *"},
	 { "SoVRMLScalarInterpolator_initClass", _wrap_SoVRMLScalarInterpolator_initClass, METH_NOARGS, "SoVRMLScalarInterpolator_initClass()"},
	 { "new_SoVRMLScalarInterpolator", _wrap_new_SoVRMLScalarInterpolator, METH_NOARGS, "new_SoVRMLScalarInterpolator() -> SoVRMLScalarInterpolator"},
	 { "SoVRMLScalarInterpolator_keyValue_set", _wrap_SoVRMLScalarInterpolator_keyValue_set, METH_VARARGS, "SoVRMLScalarInterpolator_keyValue_set(SoVRMLScalarInterpolator self, SoMFFloat keyValue)"},
	 { "SoVRMLScalarInterpolator_keyValue_get", _wrap_SoVRMLScalarInterpolator_keyValue_get, METH_O, "SoVRMLScalarInterpolator_keyValue_get(SoVRMLScalarInterpolator self) -> SoMFFloat"},
	 { "SoVRMLScalarInterpolator_value_changed_set", _wrap_SoVRMLScalarInterpolator_value_changed_set, METH_VARARGS, "SoVRMLScalarInterpolator_value_changed_set(SoVRMLScalarInterpolator self, SoEngineOutput value_changed)"},
	 { "SoVRMLScalarInterpolator_value_changed_get", _wrap_SoVRMLScalarInterpolator_value_changed_get, METH_O, "SoVRMLScalarInterpolator_value_changed_get(SoVRMLScalarInterpolator self) -> SoEngineOutput"},
	 { "SoVRMLScalarInterpolator_swigregister", SoVRMLScalarInterpolator_swigregister, METH_O, NULL},
	 { "SoVRMLScalarInterpolator_swiginit", SoVRMLScalarInterpolator_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLScript_initClass", _wrap_SoVRMLScript_initClass, METH_NOARGS, "SoVRMLScript_initClass()"},
	 { "new_SoVRMLScript", _wrap_new_SoVRMLScript, METH_NOARGS, "new_SoVRMLScript() -> SoVRMLScript"},
	 { "SoVRMLScript_getClassTypeId", _wrap_SoVRMLScript_getClassTypeId, METH_NOARGS, "SoVRMLScript_getClassTypeId() -> SoType"},
	 { "SoVRMLScript_getTypeId", _wrap_SoVRMLScript_getTypeId, METH_O, "SoVRMLScript_getTypeId(SoVRMLScript self) -> SoType"},
	 { "SoVRMLScript_url_set", _wrap_SoVRMLScript_url_set, METH_VARARGS, "SoVRMLScript_url_set(SoVRMLScript self, SoMFString url)"},
	 { "SoVRMLScript_url_get", _wrap_SoVRMLScript_url_get, METH_O, "SoVRMLScript_url_get(SoVRMLScript self) -> SoMFString"},
	 { "SoVRMLScript_directOutput_set", _wrap_SoVRMLScript_directOutput_set, METH_VARARGS, "SoVRMLScript_directOutput_set(SoVRMLScript self, SoSFBool directOutput)"},
	 { "SoVRMLScript_directOutput_get", _wrap_SoVRMLScript_directOutput_get, METH_O, "SoVRMLScript_directOutput_get(SoVRMLScript self) -> SoSFBool"},
	 { "SoVRMLScript_mustEvaluate_set", _wrap_SoVRMLScript_mustEvaluate_set, METH_VARARGS, "SoVRMLScript_mustEvaluate_set(SoVRMLScript self, SoSFBool mustEvaluate)"},
	 { "SoVRMLScript_mustEvaluate_get", _wrap_SoVRMLScript_mustEvaluate_get, METH_O, "SoVRMLScript_mustEvaluate_get(SoVRMLScript self) -> SoSFBool"},
	 { "SoVRMLScript_doAction", _wrap_SoVRMLScript_doAction, METH_VARARGS, "SoVRMLScript_doAction(SoVRMLScript self, SoAction action)"},
	 { "SoVRMLScript_callback", _wrap_SoVRMLScript_callback, METH_VARARGS, "SoVRMLScript_callback(SoVRMLScript self, SoCallbackAction action)"},
	 { "SoVRMLScript_GLRender", _wrap_SoVRMLScript_GLRender, METH_VARARGS, "SoVRMLScript_GLRender(SoVRMLScript self, SoGLRenderAction action)"},
	 { "SoVRMLScript_getBoundingBox", _wrap_SoVRMLScript_getBoundingBox, METH_VARARGS, "SoVRMLScript_getBoundingBox(SoVRMLScript self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLScript_pick", _wrap_SoVRMLScript_pick, METH_VARARGS, "SoVRMLScript_pick(SoVRMLScript self, SoPickAction action)"},
	 { "SoVRMLScript_handleEvent", _wrap_SoVRMLScript_handleEvent, METH_VARARGS, "SoVRMLScript_handleEvent(SoVRMLScript self, SoHandleEventAction action)"},
	 { "SoVRMLScript_write", _wrap_SoVRMLScript_write, METH_VARARGS, "SoVRMLScript_write(SoVRMLScript self, SoWriteAction action)"},
	 { "SoVRMLScript_setScriptEvaluateCB", _wrap_SoVRMLScript_setScriptEvaluateCB, METH_VARARGS, "SoVRMLScript_setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"},
	 { "SoVRMLScript_swigregister", SoVRMLScript_swigregister, METH_O, NULL},
	 { "SoVRMLScript_swiginit", SoVRMLScript_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLShape_getClassTypeId", _wrap_SoVRMLShape_getClassTypeId, METH_NOARGS, "SoVRMLShape_getClassTypeId() -> SoType"},
	 { "SoVRMLShape_getTypeId", _wrap_SoVRMLShape_getTypeId, METH_O, "SoVRMLShape_getTypeId(SoVRMLShape self) -> SoType"},
	 { "SoVRMLShape_initClass", _wrap_SoVRMLShape_initClass, METH_NOARGS, "SoVRMLShape_initClass()"},
	 { "new_SoVRMLShape", _wrap_new_SoVRMLShape, METH_NOARGS, "new_SoVRMLShape() -> SoVRMLShape"},
	 { "SoVRMLShape_appearance_set", _wrap_SoVRMLShape_appearance_set, METH_VARARGS, "SoVRMLShape_appearance_set(SoVRMLShape self, SoSFNode appearance)"},
	 { "SoVRMLShape_appearance_get", _wrap_SoVRMLShape_appearance_get, METH_O, "SoVRMLShape_appearance_get(SoVRMLShape self) -> SoSFNode"},
	 { "SoVRMLShape_geometry_set", _wrap_SoVRMLShape_geometry_set, METH_VARARGS, "SoVRMLShape_geometry_set(SoVRMLShape self, SoSFNode geometry)"},
	 { "SoVRMLShape_geometry_get", _wrap_SoVRMLShape_geometry_get, METH_O, "SoVRMLShape_geometry_get(SoVRMLShape self) -> SoSFNode"},
	 { "SoVRMLShape_renderCaching_set", _wrap_SoVRMLShape_renderCaching_set, METH_VARARGS, "SoVRMLShape_renderCaching_set(SoVRMLShape self, SoSFEnum renderCaching)"},
	 { "SoVRMLShape_renderCaching_get", _wrap_SoVRMLShape_renderCaching_get, METH_O, "SoVRMLShape_renderCaching_get(SoVRMLShape self) -> SoSFEnum"},
	 { "SoVRMLShape_boundingBoxCaching_set", _wrap_SoVRMLShape_boundingBoxCaching_set, METH_VARARGS, "SoVRMLShape_boundingBoxCaching_set(SoVRMLShape self, SoSFEnum boundingBoxCaching)"},
	 { "SoVRMLShape_boundingBoxCaching_get", _wrap_SoVRMLShape_boundingBoxCaching_get, METH_O, "SoVRMLShape_boundingBoxCaching_get(SoVRMLShape self) -> SoSFEnum"},
	 { "SoVRMLShape_setNumRenderCaches", _wrap_SoVRMLShape_setNumRenderCaches, METH_O, "SoVRMLShape_setNumRenderCaches(int num)"},
	 { "SoVRMLShape_getNumRenderCaches", _wrap_SoVRMLShape_getNumRenderCaches, METH_NOARGS, "SoVRMLShape_getNumRenderCaches() -> int"},
	 { "SoVRMLShape_affectsState", _wrap_SoVRMLShape_affectsState, METH_O, "SoVRMLShape_affectsState(SoVRMLShape self) -> SbBool"},
	 { "SoVRMLShape_doAction", _wrap_SoVRMLShape_doAction, METH_VARARGS, "SoVRMLShape_doAction(SoVRMLShape self, SoAction action)"},
	 { "SoVRMLShape_callback", _wrap_SoVRMLShape_callback, METH_VARARGS, "SoVRMLShape_callback(SoVRMLShape self, SoCallbackAction action)"},
	 { "SoVRMLShape_GLRender", _wrap_SoVRMLShape_GLRender, METH_VARARGS, "SoVRMLShape_GLRender(SoVRMLShape self, SoGLRenderAction action)"},
	 { "SoVRMLShape_getBoundingBox", _wrap_SoVRMLShape_getBoundingBox, METH_VARARGS, "SoVRMLShape_getBoundingBox(SoVRMLShape self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLShape_rayPick", _wrap_SoVRMLShape_rayPick, METH_VARARGS, "SoVRMLShape_rayPick(SoVRMLShape self, SoRayPickAction action)"},
	 { "SoVRMLShape_search", _wrap_SoVRMLShape_search, METH_VARARGS, "SoVRMLShape_search(SoVRMLShape self, SoSearchAction action)"},
	 { "SoVRMLShape_write", _wrap_SoVRMLShape_write, METH_VARARGS, "SoVRMLShape_write(SoVRMLShape self, SoWriteAction action)"},
	 { "SoVRMLShape_getPrimitiveCount", _wrap_SoVRMLShape_getPrimitiveCount, METH_VARARGS, "SoVRMLShape_getPrimitiveCount(SoVRMLShape self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLShape_getChildren", _wrap_SoVRMLShape_getChildren, METH_O, "SoVRMLShape_getChildren(SoVRMLShape self) -> SoChildList"},
	 { "SoVRMLShape_notify", _wrap_SoVRMLShape_notify, METH_VARARGS, "SoVRMLShape_notify(SoVRMLShape self, SoNotList list)"},
	 { "SoVRMLShape_copyContents", _wrap_SoVRMLShape_copyContents, METH_VARARGS, "SoVRMLShape_copyContents(SoVRMLShape self, SoFieldContainer srcFrom, SbBool copyConn)"},
	 { "SoVRMLShape_swigregister", SoVRMLShape_swigregister, METH_O, NULL},
	 { "SoVRMLShape_swiginit", SoVRMLShape_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSound_getClassTypeId", _wrap_SoVRMLSound_getClassTypeId, METH_NOARGS, "SoVRMLSound_getClassTypeId() -> SoType"},
	 { "SoVRMLSound_getTypeId", _wrap_SoVRMLSound_getTypeId, METH_O, "SoVRMLSound_getTypeId(SoVRMLSound self) -> SoType"},
	 { "SoVRMLSound_initClass", _wrap_SoVRMLSound_initClass, METH_NOARGS, "SoVRMLSound_initClass()"},
	 { "new_SoVRMLSound", _wrap_new_SoVRMLSound, METH_NOARGS, "new_SoVRMLSound() -> SoVRMLSound"},
	 { "SoVRMLSound_source_set", _wrap_SoVRMLSound_source_set, METH_VARARGS, "SoVRMLSound_source_set(SoVRMLSound self, SoSFNode source)"},
	 { "SoVRMLSound_source_get", _wrap_SoVRMLSound_source_get, METH_O, "SoVRMLSound_source_get(SoVRMLSound self) -> SoSFNode"},
	 { "SoVRMLSound_intensity_set", _wrap_SoVRMLSound_intensity_set, METH_VARARGS, "SoVRMLSound_intensity_set(SoVRMLSound self, SoSFFloat intensity)"},
	 { "SoVRMLSound_intensity_get", _wrap_SoVRMLSound_intensity_get, METH_O, "SoVRMLSound_intensity_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_priority_set", _wrap_SoVRMLSound_priority_set, METH_VARARGS, "SoVRMLSound_priority_set(SoVRMLSound self, SoSFFloat priority)"},
	 { "SoVRMLSound_priority_get", _wrap_SoVRMLSound_priority_get, METH_O, "SoVRMLSound_priority_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_location_set", _wrap_SoVRMLSound_location_set, METH_VARARGS, "SoVRMLSound_location_set(SoVRMLSound self, SoSFVec3f location)"},
	 { "SoVRMLSound_location_get", _wrap_SoVRMLSound_location_get, METH_O, "SoVRMLSound_location_get(SoVRMLSound self) -> SoSFVec3f"},
	 { "SoVRMLSound_direction_set", _wrap_SoVRMLSound_direction_set, METH_VARARGS, "SoVRMLSound_direction_set(SoVRMLSound self, SoSFVec3f direction)"},
	 { "SoVRMLSound_direction_get", _wrap_SoVRMLSound_direction_get, METH_O, "SoVRMLSound_direction_get(SoVRMLSound self) -> SoSFVec3f"},
	 { "SoVRMLSound_minFront_set", _wrap_SoVRMLSound_minFront_set, METH_VARARGS, "SoVRMLSound_minFront_set(SoVRMLSound self, SoSFFloat minFront)"},
	 { "SoVRMLSound_minFront_get", _wrap_SoVRMLSound_minFront_get, METH_O, "SoVRMLSound_minFront_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_maxFront_set", _wrap_SoVRMLSound_maxFront_set, METH_VARARGS, "SoVRMLSound_maxFront_set(SoVRMLSound self, SoSFFloat maxFront)"},
	 { "SoVRMLSound_maxFront_get", _wrap_SoVRMLSound_maxFront_get, METH_O, "SoVRMLSound_maxFront_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_minBack_set", _wrap_SoVRMLSound_minBack_set, METH_VARARGS, "SoVRMLSound_minBack_set(SoVRMLSound self, SoSFFloat minBack)"},
	 { "SoVRMLSound_minBack_get", _wrap_SoVRMLSound_minBack_get, METH_O, "SoVRMLSound_minBack_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_maxBack_set", _wrap_SoVRMLSound_maxBack_set, METH_VARARGS, "SoVRMLSound_maxBack_set(SoVRMLSound self, SoSFFloat maxBack)"},
	 { "SoVRMLSound_maxBack_get", _wrap_SoVRMLSound_maxBack_get, METH_O, "SoVRMLSound_maxBack_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_spatialize_set", _wrap_SoVRMLSound_spatialize_set, METH_VARARGS, "SoVRMLSound_spatialize_set(SoVRMLSound self, SoSFBool spatialize)"},
	 { "SoVRMLSound_spatialize_get", _wrap_SoVRMLSound_spatialize_get, METH_O, "SoVRMLSound_spatialize_get(SoVRMLSound self) -> SoSFBool"},
	 { "SoVRMLSound_dopplerFactor_set", _wrap_SoVRMLSound_dopplerFactor_set, METH_VARARGS, "SoVRMLSound_dopplerFactor_set(SoVRMLSound self, SoSFFloat dopplerFactor)"},
	 { "SoVRMLSound_dopplerFactor_get", _wrap_SoVRMLSound_dopplerFactor_get, METH_O, "SoVRMLSound_dopplerFactor_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_dopplerVelocity_set", _wrap_SoVRMLSound_dopplerVelocity_set, METH_VARARGS, "SoVRMLSound_dopplerVelocity_set(SoVRMLSound self, SoSFFloat dopplerVelocity)"},
	 { "SoVRMLSound_dopplerVelocity_get", _wrap_SoVRMLSound_dopplerVelocity_get, METH_O, "SoVRMLSound_dopplerVelocity_get(SoVRMLSound self) -> SoSFFloat"},
	 { "SoVRMLSound_setDopplerVelocity", _wrap_SoVRMLSound_setDopplerVelocity, METH_VARARGS, "SoVRMLSound_setDopplerVelocity(SoVRMLSound self, float velocity)"},
	 { "SoVRMLSound_getDopplerVelocity", _wrap_SoVRMLSound_getDopplerVelocity, METH_O, "SoVRMLSound_getDopplerVelocity(SoVRMLSound self) -> float"},
	 { "SoVRMLSound_setDopplerFactor", _wrap_SoVRMLSound_setDopplerFactor, METH_VARARGS, "SoVRMLSound_setDopplerFactor(SoVRMLSound self, float factor)"},
	 { "SoVRMLSound_getDopplerFactor", _wrap_SoVRMLSound_getDopplerFactor, METH_O, "SoVRMLSound_getDopplerFactor(SoVRMLSound self) -> float"},
	 { "SoVRMLSound_startPlaying", _wrap_SoVRMLSound_startPlaying, METH_VARARGS, "SoVRMLSound_startPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"},
	 { "SoVRMLSound_stopPlaying", _wrap_SoVRMLSound_stopPlaying, METH_VARARGS, "SoVRMLSound_stopPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"},
	 { "SoVRMLSound_setDefaultBufferingProperties", _wrap_SoVRMLSound_setDefaultBufferingProperties, METH_VARARGS, "SoVRMLSound_setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"},
	 { "SoVRMLSound_setBufferingProperties", _wrap_SoVRMLSound_setBufferingProperties, METH_VARARGS, "SoVRMLSound_setBufferingProperties(SoVRMLSound self, int bufferLength, int numBuffers, SbTime sleepTime)"},
	 { "SoVRMLSound_getBufferingProperties", _wrap_SoVRMLSound_getBufferingProperties, METH_VARARGS, "SoVRMLSound_getBufferingProperties(SoVRMLSound self, int & bufferLength, int & numBuffers, SbTime sleepTime)"},
	 { "SoVRMLSound_audioRender", _wrap_SoVRMLSound_audioRender, METH_VARARGS, "SoVRMLSound_audioRender(SoVRMLSound self, SoAudioRenderAction action)"},
	 { "SoVRMLSound_swigregister", SoVRMLSound_swigregister, METH_O, NULL},
	 { "SoVRMLSound_swiginit", SoVRMLSound_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSphere_getClassTypeId", _wrap_SoVRMLSphere_getClassTypeId, METH_NOARGS, "SoVRMLSphere_getClassTypeId() -> SoType"},
	 { "SoVRMLSphere_getTypeId", _wrap_SoVRMLSphere_getTypeId, METH_O, "SoVRMLSphere_getTypeId(SoVRMLSphere self) -> SoType"},
	 { "SoVRMLSphere_initClass", _wrap_SoVRMLSphere_initClass, METH_NOARGS, "SoVRMLSphere_initClass()"},
	 { "new_SoVRMLSphere", _wrap_new_SoVRMLSphere, METH_NOARGS, "new_SoVRMLSphere() -> SoVRMLSphere"},
	 { "SoVRMLSphere_radius_set", _wrap_SoVRMLSphere_radius_set, METH_VARARGS, "SoVRMLSphere_radius_set(SoVRMLSphere self, SoSFFloat radius)"},
	 { "SoVRMLSphere_radius_get", _wrap_SoVRMLSphere_radius_get, METH_O, "SoVRMLSphere_radius_get(SoVRMLSphere self) -> SoSFFloat"},
	 { "SoVRMLSphere_GLRender", _wrap_SoVRMLSphere_GLRender, METH_VARARGS, "SoVRMLSphere_GLRender(SoVRMLSphere self, SoGLRenderAction action)"},
	 { "SoVRMLSphere_rayPick", _wrap_SoVRMLSphere_rayPick, METH_VARARGS, "SoVRMLSphere_rayPick(SoVRMLSphere self, SoRayPickAction action)"},
	 { "SoVRMLSphere_getPrimitiveCount", _wrap_SoVRMLSphere_getPrimitiveCount, METH_VARARGS, "SoVRMLSphere_getPrimitiveCount(SoVRMLSphere self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLSphere_swigregister", SoVRMLSphere_swigregister, METH_O, NULL},
	 { "SoVRMLSphere_swiginit", SoVRMLSphere_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSphereSensor_getClassTypeId", _wrap_SoVRMLSphereSensor_getClassTypeId, METH_NOARGS, "SoVRMLSphereSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLSphereSensor_getTypeId", _wrap_SoVRMLSphereSensor_getTypeId, METH_O, "SoVRMLSphereSensor_getTypeId(SoVRMLSphereSensor self) -> SoType"},
	 { "SoVRMLSphereSensor_initClass", _wrap_SoVRMLSphereSensor_initClass, METH_NOARGS, "SoVRMLSphereSensor_initClass()"},
	 { "new_SoVRMLSphereSensor", _wrap_new_SoVRMLSphereSensor, METH_NOARGS, "new_SoVRMLSphereSensor() -> SoVRMLSphereSensor"},
	 { "SoVRMLSphereSensor_offset_set", _wrap_SoVRMLSphereSensor_offset_set, METH_VARARGS, "SoVRMLSphereSensor_offset_set(SoVRMLSphereSensor self, SoSFRotation offset)"},
	 { "SoVRMLSphereSensor_offset_get", _wrap_SoVRMLSphereSensor_offset_get, METH_O, "SoVRMLSphereSensor_offset_get(SoVRMLSphereSensor self) -> SoSFRotation"},
	 { "SoVRMLSphereSensor_rotation_changed_set", _wrap_SoVRMLSphereSensor_rotation_changed_set, METH_VARARGS, "SoVRMLSphereSensor_rotation_changed_set(SoVRMLSphereSensor self, SoSFRotation rotation_changed)"},
	 { "SoVRMLSphereSensor_rotation_changed_get", _wrap_SoVRMLSphereSensor_rotation_changed_get, METH_O, "SoVRMLSphereSensor_rotation_changed_get(SoVRMLSphereSensor self) -> SoSFRotation"},
	 { "SoVRMLSphereSensor_swigregister", SoVRMLSphereSensor_swigregister, METH_O, NULL},
	 { "SoVRMLSphereSensor_swiginit", SoVRMLSphereSensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSpotLight_getClassTypeId", _wrap_SoVRMLSpotLight_getClassTypeId, METH_NOARGS, "SoVRMLSpotLight_getClassTypeId() -> SoType"},
	 { "SoVRMLSpotLight_getTypeId", _wrap_SoVRMLSpotLight_getTypeId, METH_O, "SoVRMLSpotLight_getTypeId(SoVRMLSpotLight self) -> SoType"},
	 { "SoVRMLSpotLight_initClass", _wrap_SoVRMLSpotLight_initClass, METH_NOARGS, "SoVRMLSpotLight_initClass()"},
	 { "new_SoVRMLSpotLight", _wrap_new_SoVRMLSpotLight, METH_NOARGS, "new_SoVRMLSpotLight() -> SoVRMLSpotLight"},
	 { "SoVRMLSpotLight_location_set", _wrap_SoVRMLSpotLight_location_set, METH_VARARGS, "SoVRMLSpotLight_location_set(SoVRMLSpotLight self, SoSFVec3f location)"},
	 { "SoVRMLSpotLight_location_get", _wrap_SoVRMLSpotLight_location_get, METH_O, "SoVRMLSpotLight_location_get(SoVRMLSpotLight self) -> SoSFVec3f"},
	 { "SoVRMLSpotLight_direction_set", _wrap_SoVRMLSpotLight_direction_set, METH_VARARGS, "SoVRMLSpotLight_direction_set(SoVRMLSpotLight self, SoSFVec3f direction)"},
	 { "SoVRMLSpotLight_direction_get", _wrap_SoVRMLSpotLight_direction_get, METH_O, "SoVRMLSpotLight_direction_get(SoVRMLSpotLight self) -> SoSFVec3f"},
	 { "SoVRMLSpotLight_beamWidth_set", _wrap_SoVRMLSpotLight_beamWidth_set, METH_VARARGS, "SoVRMLSpotLight_beamWidth_set(SoVRMLSpotLight self, SoSFFloat beamWidth)"},
	 { "SoVRMLSpotLight_beamWidth_get", _wrap_SoVRMLSpotLight_beamWidth_get, METH_O, "SoVRMLSpotLight_beamWidth_get(SoVRMLSpotLight self) -> SoSFFloat"},
	 { "SoVRMLSpotLight_cutOffAngle_set", _wrap_SoVRMLSpotLight_cutOffAngle_set, METH_VARARGS, "SoVRMLSpotLight_cutOffAngle_set(SoVRMLSpotLight self, SoSFFloat cutOffAngle)"},
	 { "SoVRMLSpotLight_cutOffAngle_get", _wrap_SoVRMLSpotLight_cutOffAngle_get, METH_O, "SoVRMLSpotLight_cutOffAngle_get(SoVRMLSpotLight self) -> SoSFFloat"},
	 { "SoVRMLSpotLight_radius_set", _wrap_SoVRMLSpotLight_radius_set, METH_VARARGS, "SoVRMLSpotLight_radius_set(SoVRMLSpotLight self, SoSFFloat radius)"},
	 { "SoVRMLSpotLight_radius_get", _wrap_SoVRMLSpotLight_radius_get, METH_O, "SoVRMLSpotLight_radius_get(SoVRMLSpotLight self) -> SoSFFloat"},
	 { "SoVRMLSpotLight_attenuation_set", _wrap_SoVRMLSpotLight_attenuation_set, METH_VARARGS, "SoVRMLSpotLight_attenuation_set(SoVRMLSpotLight self, SoSFVec3f attenuation)"},
	 { "SoVRMLSpotLight_attenuation_get", _wrap_SoVRMLSpotLight_attenuation_get, METH_O, "SoVRMLSpotLight_attenuation_get(SoVRMLSpotLight self) -> SoSFVec3f"},
	 { "SoVRMLSpotLight_GLRender", _wrap_SoVRMLSpotLight_GLRender, METH_VARARGS, "SoVRMLSpotLight_GLRender(SoVRMLSpotLight self, SoGLRenderAction action)"},
	 { "SoVRMLSpotLight_swigregister", SoVRMLSpotLight_swigregister, METH_O, NULL},
	 { "SoVRMLSpotLight_swiginit", SoVRMLSpotLight_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLSwitch_getClassTypeId", _wrap_SoVRMLSwitch_getClassTypeId, METH_NOARGS, "SoVRMLSwitch_getClassTypeId() -> SoType"},
	 { "SoVRMLSwitch_getTypeId", _wrap_SoVRMLSwitch_getTypeId, METH_O, "SoVRMLSwitch_getTypeId(SoVRMLSwitch self) -> SoType"},
	 { "SoVRMLSwitch_initClass", _wrap_SoVRMLSwitch_initClass, METH_NOARGS, "SoVRMLSwitch_initClass()"},
	 { "new_SoVRMLSwitch", _wrap_new_SoVRMLSwitch, METH_VARARGS, "\n"
		"SoVRMLSwitch()\n"
		"new_SoVRMLSwitch(int choices) -> SoVRMLSwitch\n"
		""},
	 { "SoVRMLSwitch_choice_set", _wrap_SoVRMLSwitch_choice_set, METH_VARARGS, "SoVRMLSwitch_choice_set(SoVRMLSwitch self, SoMFNode choice)"},
	 { "SoVRMLSwitch_choice_get", _wrap_SoVRMLSwitch_choice_get, METH_O, "SoVRMLSwitch_choice_get(SoVRMLSwitch self) -> SoMFNode"},
	 { "SoVRMLSwitch_whichChoice_set", _wrap_SoVRMLSwitch_whichChoice_set, METH_VARARGS, "SoVRMLSwitch_whichChoice_set(SoVRMLSwitch self, SoSFInt32 whichChoice)"},
	 { "SoVRMLSwitch_whichChoice_get", _wrap_SoVRMLSwitch_whichChoice_get, METH_O, "SoVRMLSwitch_whichChoice_get(SoVRMLSwitch self) -> SoSFInt32"},
	 { "SoVRMLSwitch_affectsState", _wrap_SoVRMLSwitch_affectsState, METH_O, "SoVRMLSwitch_affectsState(SoVRMLSwitch self) -> SbBool"},
	 { "SoVRMLSwitch_addChoice", _wrap_SoVRMLSwitch_addChoice, METH_VARARGS, "SoVRMLSwitch_addChoice(SoVRMLSwitch self, SoNode choice)"},
	 { "SoVRMLSwitch_insertChoice", _wrap_SoVRMLSwitch_insertChoice, METH_VARARGS, "SoVRMLSwitch_insertChoice(SoVRMLSwitch self, SoNode choice, int idx)"},
	 { "SoVRMLSwitch_getChoice", _wrap_SoVRMLSwitch_getChoice, METH_VARARGS, "SoVRMLSwitch_getChoice(SoVRMLSwitch self, int idx) -> SoNode"},
	 { "SoVRMLSwitch_findChoice", _wrap_SoVRMLSwitch_findChoice, METH_VARARGS, "SoVRMLSwitch_findChoice(SoVRMLSwitch self, SoNode choice) -> int"},
	 { "SoVRMLSwitch_getNumChoices", _wrap_SoVRMLSwitch_getNumChoices, METH_O, "SoVRMLSwitch_getNumChoices(SoVRMLSwitch self) -> int"},
	 { "SoVRMLSwitch_removeChoice", _wrap_SoVRMLSwitch_removeChoice, METH_VARARGS, "\n"
		"SoVRMLSwitch_removeChoice(SoVRMLSwitch self, int idx)\n"
		"SoVRMLSwitch_removeChoice(SoVRMLSwitch self, SoNode node)\n"
		""},
	 { "SoVRMLSwitch_removeAllChoices", _wrap_SoVRMLSwitch_removeAllChoices, METH_O, "SoVRMLSwitch_removeAllChoices(SoVRMLSwitch self)"},
	 { "SoVRMLSwitch_replaceChoice", _wrap_SoVRMLSwitch_replaceChoice, METH_VARARGS, "\n"
		"SoVRMLSwitch_replaceChoice(SoVRMLSwitch self, int idx, SoNode choice)\n"
		"SoVRMLSwitch_replaceChoice(SoVRMLSwitch self, SoNode old, SoNode choice)\n"
		""},
	 { "SoVRMLSwitch_doAction", _wrap_SoVRMLSwitch_doAction, METH_VARARGS, "SoVRMLSwitch_doAction(SoVRMLSwitch self, SoAction action)"},
	 { "SoVRMLSwitch_callback", _wrap_SoVRMLSwitch_callback, METH_VARARGS, "SoVRMLSwitch_callback(SoVRMLSwitch self, SoCallbackAction action)"},
	 { "SoVRMLSwitch_GLRender", _wrap_SoVRMLSwitch_GLRender, METH_VARARGS, "SoVRMLSwitch_GLRender(SoVRMLSwitch self, SoGLRenderAction action)"},
	 { "SoVRMLSwitch_pick", _wrap_SoVRMLSwitch_pick, METH_VARARGS, "SoVRMLSwitch_pick(SoVRMLSwitch self, SoPickAction action)"},
	 { "SoVRMLSwitch_getBoundingBox", _wrap_SoVRMLSwitch_getBoundingBox, METH_VARARGS, "SoVRMLSwitch_getBoundingBox(SoVRMLSwitch self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLSwitch_handleEvent", _wrap_SoVRMLSwitch_handleEvent, METH_VARARGS, "SoVRMLSwitch_handleEvent(SoVRMLSwitch self, SoHandleEventAction action)"},
	 { "SoVRMLSwitch_getMatrix", _wrap_SoVRMLSwitch_getMatrix, METH_VARARGS, "SoVRMLSwitch_getMatrix(SoVRMLSwitch self, SoGetMatrixAction action)"},
	 { "SoVRMLSwitch_search", _wrap_SoVRMLSwitch_search, METH_VARARGS, "SoVRMLSwitch_search(SoVRMLSwitch self, SoSearchAction action)"},
	 { "SoVRMLSwitch_write", _wrap_SoVRMLSwitch_write, METH_VARARGS, "SoVRMLSwitch_write(SoVRMLSwitch self, SoWriteAction action)"},
	 { "SoVRMLSwitch_audioRender", _wrap_SoVRMLSwitch_audioRender, METH_VARARGS, "SoVRMLSwitch_audioRender(SoVRMLSwitch self, SoAudioRenderAction action)"},
	 { "SoVRMLSwitch_addChild", _wrap_SoVRMLSwitch_addChild, METH_VARARGS, "SoVRMLSwitch_addChild(SoVRMLSwitch self, SoNode child)"},
	 { "SoVRMLSwitch_insertChild", _wrap_SoVRMLSwitch_insertChild, METH_VARARGS, "SoVRMLSwitch_insertChild(SoVRMLSwitch self, SoNode child, int idx)"},
	 { "SoVRMLSwitch_getChild", _wrap_SoVRMLSwitch_getChild, METH_VARARGS, "SoVRMLSwitch_getChild(SoVRMLSwitch self, int idx) -> SoNode"},
	 { "SoVRMLSwitch_findChild", _wrap_SoVRMLSwitch_findChild, METH_VARARGS, "SoVRMLSwitch_findChild(SoVRMLSwitch self, SoNode child) -> int"},
	 { "SoVRMLSwitch_getNumChildren", _wrap_SoVRMLSwitch_getNumChildren, METH_O, "SoVRMLSwitch_getNumChildren(SoVRMLSwitch self) -> int"},
	 { "SoVRMLSwitch_removeChild", _wrap_SoVRMLSwitch_removeChild, METH_VARARGS, "\n"
		"SoVRMLSwitch_removeChild(SoVRMLSwitch self, int idx)\n"
		"SoVRMLSwitch_removeChild(SoVRMLSwitch self, SoNode child)\n"
		""},
	 { "SoVRMLSwitch_removeAllChildren", _wrap_SoVRMLSwitch_removeAllChildren, METH_O, "SoVRMLSwitch_removeAllChildren(SoVRMLSwitch self)"},
	 { "SoVRMLSwitch_replaceChild", _wrap_SoVRMLSwitch_replaceChild, METH_VARARGS, "\n"
		"SoVRMLSwitch_replaceChild(SoVRMLSwitch self, int idx, SoNode node)\n"
		"SoVRMLSwitch_replaceChild(SoVRMLSwitch self, SoNode old, SoNode node)\n"
		""},
	 { "SoVRMLSwitch_getChildren", _wrap_SoVRMLSwitch_getChildren, METH_O, "SoVRMLSwitch_getChildren(SoVRMLSwitch self) -> SoChildList"},
	 { "SoVRMLSwitch_swigregister", SoVRMLSwitch_swigregister, METH_O, NULL},
	 { "SoVRMLSwitch_swiginit", SoVRMLSwitch_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLText_getClassTypeId", _wrap_SoVRMLText_getClassTypeId, METH_NOARGS, "SoVRMLText_getClassTypeId() -> SoType"},
	 { "SoVRMLText_getTypeId", _wrap_SoVRMLText_getTypeId, METH_O, "SoVRMLText_getTypeId(SoVRMLText self) -> SoType"},
	 { "SoVRMLText_initClass", _wrap_SoVRMLText_initClass, METH_NOARGS, "SoVRMLText_initClass()"},
	 { "new_SoVRMLText", _wrap_new_SoVRMLText, METH_NOARGS, "new_SoVRMLText() -> SoVRMLText"},
	 { "SoVRMLText_string_set", _wrap_SoVRMLText_string_set, METH_VARARGS, "SoVRMLText_string_set(SoVRMLText self, SoMFString string)"},
	 { "SoVRMLText_string_get", _wrap_SoVRMLText_string_get, METH_O, "SoVRMLText_string_get(SoVRMLText self) -> SoMFString"},
	 { "SoVRMLText_fontStyle_set", _wrap_SoVRMLText_fontStyle_set, METH_VARARGS, "SoVRMLText_fontStyle_set(SoVRMLText self, SoSFNode fontStyle)"},
	 { "SoVRMLText_fontStyle_get", _wrap_SoVRMLText_fontStyle_get, METH_O, "SoVRMLText_fontStyle_get(SoVRMLText self) -> SoSFNode"},
	 { "SoVRMLText_maxExtent_set", _wrap_SoVRMLText_maxExtent_set, METH_VARARGS, "SoVRMLText_maxExtent_set(SoVRMLText self, SoSFFloat maxExtent)"},
	 { "SoVRMLText_maxExtent_get", _wrap_SoVRMLText_maxExtent_get, METH_O, "SoVRMLText_maxExtent_get(SoVRMLText self) -> SoSFFloat"},
	 { "SoVRMLText_length_set", _wrap_SoVRMLText_length_set, METH_VARARGS, "SoVRMLText_length_set(SoVRMLText self, SoMFFloat length)"},
	 { "SoVRMLText_length_get", _wrap_SoVRMLText_length_get, METH_O, "SoVRMLText_length_get(SoVRMLText self) -> SoMFFloat"},
	 { "SoVRMLText_GLRender", _wrap_SoVRMLText_GLRender, METH_VARARGS, "SoVRMLText_GLRender(SoVRMLText self, SoGLRenderAction action)"},
	 { "SoVRMLText_getPrimitiveCount", _wrap_SoVRMLText_getPrimitiveCount, METH_VARARGS, "SoVRMLText_getPrimitiveCount(SoVRMLText self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLText_notify", _wrap_SoVRMLText_notify, METH_VARARGS, "SoVRMLText_notify(SoVRMLText self, SoNotList list)"},
	 { "SoVRMLText_getChildren", _wrap_SoVRMLText_getChildren, METH_O, "SoVRMLText_getChildren(SoVRMLText self) -> SoChildList"},
	 { "SoVRMLText_swigregister", SoVRMLText_swigregister, METH_O, NULL},
	 { "SoVRMLText_swiginit", SoVRMLText_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLTextureCoordinate_getClassTypeId", _wrap_SoVRMLTextureCoordinate_getClassTypeId, METH_NOARGS, "SoVRMLTextureCoordinate_getClassTypeId() -> SoType"},
	 { "SoVRMLTextureCoordinate_getTypeId", _wrap_SoVRMLTextureCoordinate_getTypeId, METH_O, "SoVRMLTextureCoordinate_getTypeId(SoVRMLTextureCoordinate self) -> SoType"},
	 { "SoVRMLTextureCoordinate_initClass", _wrap_SoVRMLTextureCoordinate_initClass, METH_NOARGS, "SoVRMLTextureCoordinate_initClass()"},
	 { "new_SoVRMLTextureCoordinate", _wrap_new_SoVRMLTextureCoordinate, METH_NOARGS, "new_SoVRMLTextureCoordinate() -> SoVRMLTextureCoordinate"},
	 { "SoVRMLTextureCoordinate_point_set", _wrap_SoVRMLTextureCoordinate_point_set, METH_VARARGS, "SoVRMLTextureCoordinate_point_set(SoVRMLTextureCoordinate self, SoMFVec2f point)"},
	 { "SoVRMLTextureCoordinate_point_get", _wrap_SoVRMLTextureCoordinate_point_get, METH_O, "SoVRMLTextureCoordinate_point_get(SoVRMLTextureCoordinate self) -> SoMFVec2f"},
	 { "SoVRMLTextureCoordinate_doAction", _wrap_SoVRMLTextureCoordinate_doAction, METH_VARARGS, "SoVRMLTextureCoordinate_doAction(SoVRMLTextureCoordinate self, SoAction action)"},
	 { "SoVRMLTextureCoordinate_callback", _wrap_SoVRMLTextureCoordinate_callback, METH_VARARGS, "SoVRMLTextureCoordinate_callback(SoVRMLTextureCoordinate self, SoCallbackAction action)"},
	 { "SoVRMLTextureCoordinate_GLRender", _wrap_SoVRMLTextureCoordinate_GLRender, METH_VARARGS, "SoVRMLTextureCoordinate_GLRender(SoVRMLTextureCoordinate self, SoGLRenderAction action)"},
	 { "SoVRMLTextureCoordinate_pick", _wrap_SoVRMLTextureCoordinate_pick, METH_VARARGS, "SoVRMLTextureCoordinate_pick(SoVRMLTextureCoordinate self, SoPickAction action)"},
	 { "SoVRMLTextureCoordinate_getPrimitiveCount", _wrap_SoVRMLTextureCoordinate_getPrimitiveCount, METH_VARARGS, "SoVRMLTextureCoordinate_getPrimitiveCount(SoVRMLTextureCoordinate self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLTextureCoordinate_swigregister", SoVRMLTextureCoordinate_swigregister, METH_O, NULL},
	 { "SoVRMLTextureCoordinate_swiginit", SoVRMLTextureCoordinate_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLTextureTransform_getClassTypeId", _wrap_SoVRMLTextureTransform_getClassTypeId, METH_NOARGS, "SoVRMLTextureTransform_getClassTypeId() -> SoType"},
	 { "SoVRMLTextureTransform_getTypeId", _wrap_SoVRMLTextureTransform_getTypeId, METH_O, "SoVRMLTextureTransform_getTypeId(SoVRMLTextureTransform self) -> SoType"},
	 { "SoVRMLTextureTransform_initClass", _wrap_SoVRMLTextureTransform_initClass, METH_NOARGS, "SoVRMLTextureTransform_initClass()"},
	 { "new_SoVRMLTextureTransform", _wrap_new_SoVRMLTextureTransform, METH_NOARGS, "new_SoVRMLTextureTransform() -> SoVRMLTextureTransform"},
	 { "SoVRMLTextureTransform_translation_set", _wrap_SoVRMLTextureTransform_translation_set, METH_VARARGS, "SoVRMLTextureTransform_translation_set(SoVRMLTextureTransform self, SoSFVec2f translation)"},
	 { "SoVRMLTextureTransform_translation_get", _wrap_SoVRMLTextureTransform_translation_get, METH_O, "SoVRMLTextureTransform_translation_get(SoVRMLTextureTransform self) -> SoSFVec2f"},
	 { "SoVRMLTextureTransform_rotation_set", _wrap_SoVRMLTextureTransform_rotation_set, METH_VARARGS, "SoVRMLTextureTransform_rotation_set(SoVRMLTextureTransform self, SoSFFloat rotation)"},
	 { "SoVRMLTextureTransform_rotation_get", _wrap_SoVRMLTextureTransform_rotation_get, METH_O, "SoVRMLTextureTransform_rotation_get(SoVRMLTextureTransform self) -> SoSFFloat"},
	 { "SoVRMLTextureTransform_scale_set", _wrap_SoVRMLTextureTransform_scale_set, METH_VARARGS, "SoVRMLTextureTransform_scale_set(SoVRMLTextureTransform self, SoSFVec2f scale)"},
	 { "SoVRMLTextureTransform_scale_get", _wrap_SoVRMLTextureTransform_scale_get, METH_O, "SoVRMLTextureTransform_scale_get(SoVRMLTextureTransform self) -> SoSFVec2f"},
	 { "SoVRMLTextureTransform_center_set", _wrap_SoVRMLTextureTransform_center_set, METH_VARARGS, "SoVRMLTextureTransform_center_set(SoVRMLTextureTransform self, SoSFVec2f center)"},
	 { "SoVRMLTextureTransform_center_get", _wrap_SoVRMLTextureTransform_center_get, METH_O, "SoVRMLTextureTransform_center_get(SoVRMLTextureTransform self) -> SoSFVec2f"},
	 { "SoVRMLTextureTransform_doAction", _wrap_SoVRMLTextureTransform_doAction, METH_VARARGS, "SoVRMLTextureTransform_doAction(SoVRMLTextureTransform self, SoAction action)"},
	 { "SoVRMLTextureTransform_callback", _wrap_SoVRMLTextureTransform_callback, METH_VARARGS, "SoVRMLTextureTransform_callback(SoVRMLTextureTransform self, SoCallbackAction action)"},
	 { "SoVRMLTextureTransform_GLRender", _wrap_SoVRMLTextureTransform_GLRender, METH_VARARGS, "SoVRMLTextureTransform_GLRender(SoVRMLTextureTransform self, SoGLRenderAction action)"},
	 { "SoVRMLTextureTransform_getMatrix", _wrap_SoVRMLTextureTransform_getMatrix, METH_VARARGS, "SoVRMLTextureTransform_getMatrix(SoVRMLTextureTransform self, SoGetMatrixAction action)"},
	 { "SoVRMLTextureTransform_pick", _wrap_SoVRMLTextureTransform_pick, METH_VARARGS, "SoVRMLTextureTransform_pick(SoVRMLTextureTransform self, SoPickAction action)"},
	 { "SoVRMLTextureTransform_swigregister", SoVRMLTextureTransform_swigregister, METH_O, NULL},
	 { "SoVRMLTextureTransform_swiginit", SoVRMLTextureTransform_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLTimeSensor_getClassTypeId", _wrap_SoVRMLTimeSensor_getClassTypeId, METH_NOARGS, "SoVRMLTimeSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLTimeSensor_getTypeId", _wrap_SoVRMLTimeSensor_getTypeId, METH_O, "SoVRMLTimeSensor_getTypeId(SoVRMLTimeSensor self) -> SoType"},
	 { "SoVRMLTimeSensor_getOutputData", _wrap_SoVRMLTimeSensor_getOutputData, METH_O, "SoVRMLTimeSensor_getOutputData(SoVRMLTimeSensor self) -> SoEngineOutputData"},
	 { "SoVRMLTimeSensor_createInstance", _wrap_SoVRMLTimeSensor_createInstance, METH_NOARGS, "SoVRMLTimeSensor_createInstance() -> void *"},
	 { "SoVRMLTimeSensor_initClass", _wrap_SoVRMLTimeSensor_initClass, METH_NOARGS, "SoVRMLTimeSensor_initClass()"},
	 { "new_SoVRMLTimeSensor", _wrap_new_SoVRMLTimeSensor, METH_NOARGS, "new_SoVRMLTimeSensor() -> SoVRMLTimeSensor"},
	 { "SoVRMLTimeSensor_cycleInterval_set", _wrap_SoVRMLTimeSensor_cycleInterval_set, METH_VARARGS, "SoVRMLTimeSensor_cycleInterval_set(SoVRMLTimeSensor self, SoSFTime cycleInterval)"},
	 { "SoVRMLTimeSensor_cycleInterval_get", _wrap_SoVRMLTimeSensor_cycleInterval_get, METH_O, "SoVRMLTimeSensor_cycleInterval_get(SoVRMLTimeSensor self) -> SoSFTime"},
	 { "SoVRMLTimeSensor_enabled_set", _wrap_SoVRMLTimeSensor_enabled_set, METH_VARARGS, "SoVRMLTimeSensor_enabled_set(SoVRMLTimeSensor self, SoSFBool enabled)"},
	 { "SoVRMLTimeSensor_enabled_get", _wrap_SoVRMLTimeSensor_enabled_get, METH_O, "SoVRMLTimeSensor_enabled_get(SoVRMLTimeSensor self) -> SoSFBool"},
	 { "SoVRMLTimeSensor_loop_set", _wrap_SoVRMLTimeSensor_loop_set, METH_VARARGS, "SoVRMLTimeSensor_loop_set(SoVRMLTimeSensor self, SoSFBool loop)"},
	 { "SoVRMLTimeSensor_loop_get", _wrap_SoVRMLTimeSensor_loop_get, METH_O, "SoVRMLTimeSensor_loop_get(SoVRMLTimeSensor self) -> SoSFBool"},
	 { "SoVRMLTimeSensor_startTime_set", _wrap_SoVRMLTimeSensor_startTime_set, METH_VARARGS, "SoVRMLTimeSensor_startTime_set(SoVRMLTimeSensor self, SoSFTime startTime)"},
	 { "SoVRMLTimeSensor_startTime_get", _wrap_SoVRMLTimeSensor_startTime_get, METH_O, "SoVRMLTimeSensor_startTime_get(SoVRMLTimeSensor self) -> SoSFTime"},
	 { "SoVRMLTimeSensor_stopTime_set", _wrap_SoVRMLTimeSensor_stopTime_set, METH_VARARGS, "SoVRMLTimeSensor_stopTime_set(SoVRMLTimeSensor self, SoSFTime stopTime)"},
	 { "SoVRMLTimeSensor_stopTime_get", _wrap_SoVRMLTimeSensor_stopTime_get, METH_O, "SoVRMLTimeSensor_stopTime_get(SoVRMLTimeSensor self) -> SoSFTime"},
	 { "SoVRMLTimeSensor_notify", _wrap_SoVRMLTimeSensor_notify, METH_VARARGS, "SoVRMLTimeSensor_notify(SoVRMLTimeSensor self, SoNotList list)"},
	 { "SoVRMLTimeSensor_handleEvent", _wrap_SoVRMLTimeSensor_handleEvent, METH_VARARGS, "SoVRMLTimeSensor_handleEvent(SoVRMLTimeSensor self, SoHandleEventAction action)"},
	 { "SoVRMLTimeSensor_write", _wrap_SoVRMLTimeSensor_write, METH_VARARGS, "SoVRMLTimeSensor_write(SoVRMLTimeSensor self, SoWriteAction action)"},
	 { "SoVRMLTimeSensor_cycleTime_set", _wrap_SoVRMLTimeSensor_cycleTime_set, METH_VARARGS, "SoVRMLTimeSensor_cycleTime_set(SoVRMLTimeSensor self, SoEngineOutput cycleTime)"},
	 { "SoVRMLTimeSensor_cycleTime_get", _wrap_SoVRMLTimeSensor_cycleTime_get, METH_O, "SoVRMLTimeSensor_cycleTime_get(SoVRMLTimeSensor self) -> SoEngineOutput"},
	 { "SoVRMLTimeSensor_fraction_changed_set", _wrap_SoVRMLTimeSensor_fraction_changed_set, METH_VARARGS, "SoVRMLTimeSensor_fraction_changed_set(SoVRMLTimeSensor self, SoEngineOutput fraction_changed)"},
	 { "SoVRMLTimeSensor_fraction_changed_get", _wrap_SoVRMLTimeSensor_fraction_changed_get, METH_O, "SoVRMLTimeSensor_fraction_changed_get(SoVRMLTimeSensor self) -> SoEngineOutput"},
	 { "SoVRMLTimeSensor_isActive_set", _wrap_SoVRMLTimeSensor_isActive_set, METH_VARARGS, "SoVRMLTimeSensor_isActive_set(SoVRMLTimeSensor self, SoEngineOutput isActive)"},
	 { "SoVRMLTimeSensor_isActive_get", _wrap_SoVRMLTimeSensor_isActive_get, METH_O, "SoVRMLTimeSensor_isActive_get(SoVRMLTimeSensor self) -> SoEngineOutput"},
	 { "SoVRMLTimeSensor_time_set", _wrap_SoVRMLTimeSensor_time_set, METH_VARARGS, "SoVRMLTimeSensor_time_set(SoVRMLTimeSensor self, SoEngineOutput time)"},
	 { "SoVRMLTimeSensor_time_get", _wrap_SoVRMLTimeSensor_time_get, METH_O, "SoVRMLTimeSensor_time_get(SoVRMLTimeSensor self) -> SoEngineOutput"},
	 { "SoVRMLTimeSensor_swigregister", SoVRMLTimeSensor_swigregister, METH_O, NULL},
	 { "SoVRMLTimeSensor_swiginit", SoVRMLTimeSensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLTouchSensor_getClassTypeId", _wrap_SoVRMLTouchSensor_getClassTypeId, METH_NOARGS, "SoVRMLTouchSensor_getClassTypeId() -> SoType"},
	 { "SoVRMLTouchSensor_getTypeId", _wrap_SoVRMLTouchSensor_getTypeId, METH_O, "SoVRMLTouchSensor_getTypeId(SoVRMLTouchSensor self) -> SoType"},
	 { "SoVRMLTouchSensor_initClass", _wrap_SoVRMLTouchSensor_initClass, METH_NOARGS, "SoVRMLTouchSensor_initClass()"},
	 { "new_SoVRMLTouchSensor", _wrap_new_SoVRMLTouchSensor, METH_NOARGS, "new_SoVRMLTouchSensor() -> SoVRMLTouchSensor"},
	 { "SoVRMLTouchSensor_enabled_set", _wrap_SoVRMLTouchSensor_enabled_set, METH_VARARGS, "SoVRMLTouchSensor_enabled_set(SoVRMLTouchSensor self, SoSFBool enabled)"},
	 { "SoVRMLTouchSensor_enabled_get", _wrap_SoVRMLTouchSensor_enabled_get, METH_O, "SoVRMLTouchSensor_enabled_get(SoVRMLTouchSensor self) -> SoSFBool"},
	 { "SoVRMLTouchSensor_hitNormal_changed_set", _wrap_SoVRMLTouchSensor_hitNormal_changed_set, METH_VARARGS, "SoVRMLTouchSensor_hitNormal_changed_set(SoVRMLTouchSensor self, SoSFVec3f hitNormal_changed)"},
	 { "SoVRMLTouchSensor_hitNormal_changed_get", _wrap_SoVRMLTouchSensor_hitNormal_changed_get, METH_O, "SoVRMLTouchSensor_hitNormal_changed_get(SoVRMLTouchSensor self) -> SoSFVec3f"},
	 { "SoVRMLTouchSensor_hitPoint_changed_set", _wrap_SoVRMLTouchSensor_hitPoint_changed_set, METH_VARARGS, "SoVRMLTouchSensor_hitPoint_changed_set(SoVRMLTouchSensor self, SoSFVec3f hitPoint_changed)"},
	 { "SoVRMLTouchSensor_hitPoint_changed_get", _wrap_SoVRMLTouchSensor_hitPoint_changed_get, METH_O, "SoVRMLTouchSensor_hitPoint_changed_get(SoVRMLTouchSensor self) -> SoSFVec3f"},
	 { "SoVRMLTouchSensor_hitTexCoord_changed_set", _wrap_SoVRMLTouchSensor_hitTexCoord_changed_set, METH_VARARGS, "SoVRMLTouchSensor_hitTexCoord_changed_set(SoVRMLTouchSensor self, SoSFVec2f hitTexCoord_changed)"},
	 { "SoVRMLTouchSensor_hitTexCoord_changed_get", _wrap_SoVRMLTouchSensor_hitTexCoord_changed_get, METH_O, "SoVRMLTouchSensor_hitTexCoord_changed_get(SoVRMLTouchSensor self) -> SoSFVec2f"},
	 { "SoVRMLTouchSensor_isActive_set", _wrap_SoVRMLTouchSensor_isActive_set, METH_VARARGS, "SoVRMLTouchSensor_isActive_set(SoVRMLTouchSensor self, SoSFBool isActive)"},
	 { "SoVRMLTouchSensor_isActive_get", _wrap_SoVRMLTouchSensor_isActive_get, METH_O, "SoVRMLTouchSensor_isActive_get(SoVRMLTouchSensor self) -> SoSFBool"},
	 { "SoVRMLTouchSensor_isOver_set", _wrap_SoVRMLTouchSensor_isOver_set, METH_VARARGS, "SoVRMLTouchSensor_isOver_set(SoVRMLTouchSensor self, SoSFBool isOver)"},
	 { "SoVRMLTouchSensor_isOver_get", _wrap_SoVRMLTouchSensor_isOver_get, METH_O, "SoVRMLTouchSensor_isOver_get(SoVRMLTouchSensor self) -> SoSFBool"},
	 { "SoVRMLTouchSensor_touchTime_set", _wrap_SoVRMLTouchSensor_touchTime_set, METH_VARARGS, "SoVRMLTouchSensor_touchTime_set(SoVRMLTouchSensor self, SoSFTime touchTime)"},
	 { "SoVRMLTouchSensor_touchTime_get", _wrap_SoVRMLTouchSensor_touchTime_get, METH_O, "SoVRMLTouchSensor_touchTime_get(SoVRMLTouchSensor self) -> SoSFTime"},
	 { "SoVRMLTouchSensor_affectsState", _wrap_SoVRMLTouchSensor_affectsState, METH_O, "SoVRMLTouchSensor_affectsState(SoVRMLTouchSensor self) -> SbBool"},
	 { "SoVRMLTouchSensor_handleEvent", _wrap_SoVRMLTouchSensor_handleEvent, METH_VARARGS, "SoVRMLTouchSensor_handleEvent(SoVRMLTouchSensor self, SoHandleEventAction action)"},
	 { "SoVRMLTouchSensor_swigregister", SoVRMLTouchSensor_swigregister, METH_O, NULL},
	 { "SoVRMLTouchSensor_swiginit", SoVRMLTouchSensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLTransform_getClassTypeId", _wrap_SoVRMLTransform_getClassTypeId, METH_NOARGS, "SoVRMLTransform_getClassTypeId() -> SoType"},
	 { "SoVRMLTransform_getTypeId", _wrap_SoVRMLTransform_getTypeId, METH_O, "SoVRMLTransform_getTypeId(SoVRMLTransform self) -> SoType"},
	 { "SoVRMLTransform_initClass", _wrap_SoVRMLTransform_initClass, METH_NOARGS, "SoVRMLTransform_initClass()"},
	 { "new_SoVRMLTransform", _wrap_new_SoVRMLTransform, METH_VARARGS, "\n"
		"SoVRMLTransform()\n"
		"new_SoVRMLTransform(int children) -> SoVRMLTransform\n"
		""},
	 { "SoVRMLTransform_translation_set", _wrap_SoVRMLTransform_translation_set, METH_VARARGS, "SoVRMLTransform_translation_set(SoVRMLTransform self, SoSFVec3f translation)"},
	 { "SoVRMLTransform_translation_get", _wrap_SoVRMLTransform_translation_get, METH_O, "SoVRMLTransform_translation_get(SoVRMLTransform self) -> SoSFVec3f"},
	 { "SoVRMLTransform_rotation_set", _wrap_SoVRMLTransform_rotation_set, METH_VARARGS, "SoVRMLTransform_rotation_set(SoVRMLTransform self, SoSFRotation rotation)"},
	 { "SoVRMLTransform_rotation_get", _wrap_SoVRMLTransform_rotation_get, METH_O, "SoVRMLTransform_rotation_get(SoVRMLTransform self) -> SoSFRotation"},
	 { "SoVRMLTransform_scale_set", _wrap_SoVRMLTransform_scale_set, METH_VARARGS, "SoVRMLTransform_scale_set(SoVRMLTransform self, SoSFVec3f scale)"},
	 { "SoVRMLTransform_scale_get", _wrap_SoVRMLTransform_scale_get, METH_O, "SoVRMLTransform_scale_get(SoVRMLTransform self) -> SoSFVec3f"},
	 { "SoVRMLTransform_scaleOrientation_set", _wrap_SoVRMLTransform_scaleOrientation_set, METH_VARARGS, "SoVRMLTransform_scaleOrientation_set(SoVRMLTransform self, SoSFRotation scaleOrientation)"},
	 { "SoVRMLTransform_scaleOrientation_get", _wrap_SoVRMLTransform_scaleOrientation_get, METH_O, "SoVRMLTransform_scaleOrientation_get(SoVRMLTransform self) -> SoSFRotation"},
	 { "SoVRMLTransform_center_set", _wrap_SoVRMLTransform_center_set, METH_VARARGS, "SoVRMLTransform_center_set(SoVRMLTransform self, SoSFVec3f center)"},
	 { "SoVRMLTransform_center_get", _wrap_SoVRMLTransform_center_get, METH_O, "SoVRMLTransform_center_get(SoVRMLTransform self) -> SoSFVec3f"},
	 { "SoVRMLTransform_pointAt", _wrap_SoVRMLTransform_pointAt, METH_VARARGS, "SoVRMLTransform_pointAt(SoVRMLTransform self, SbVec3f srcFrom, SbVec3f destTo)"},
	 { "SoVRMLTransform_getScaleSpaceMatrix", _wrap_SoVRMLTransform_getScaleSpaceMatrix, METH_VARARGS, "SoVRMLTransform_getScaleSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"},
	 { "SoVRMLTransform_getRotationSpaceMatrix", _wrap_SoVRMLTransform_getRotationSpaceMatrix, METH_VARARGS, "SoVRMLTransform_getRotationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"},
	 { "SoVRMLTransform_getTranslationSpaceMatrix", _wrap_SoVRMLTransform_getTranslationSpaceMatrix, METH_VARARGS, "SoVRMLTransform_getTranslationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"},
	 { "SoVRMLTransform_multLeft", _wrap_SoVRMLTransform_multLeft, METH_O, "SoVRMLTransform_multLeft(SoVRMLTransform self)"},
	 { "SoVRMLTransform_multRight", _wrap_SoVRMLTransform_multRight, METH_O, "SoVRMLTransform_multRight(SoVRMLTransform self)"},
	 { "SoVRMLTransform_combineLeft", _wrap_SoVRMLTransform_combineLeft, METH_VARARGS, "SoVRMLTransform_combineLeft(SoVRMLTransform self, SoVRMLTransform leftnode)"},
	 { "SoVRMLTransform_combineRight", _wrap_SoVRMLTransform_combineRight, METH_VARARGS, "SoVRMLTransform_combineRight(SoVRMLTransform self, SoVRMLTransform rightnode)"},
	 { "SoVRMLTransform_setMatrix", _wrap_SoVRMLTransform_setMatrix, METH_O, "SoVRMLTransform_setMatrix(SoVRMLTransform self)"},
	 { "SoVRMLTransform_recenter", _wrap_SoVRMLTransform_recenter, METH_VARARGS, "SoVRMLTransform_recenter(SoVRMLTransform self, SbVec3f newcenter)"},
	 { "SoVRMLTransform_doAction", _wrap_SoVRMLTransform_doAction, METH_VARARGS, "SoVRMLTransform_doAction(SoVRMLTransform self, SoAction action)"},
	 { "SoVRMLTransform_callback", _wrap_SoVRMLTransform_callback, METH_VARARGS, "SoVRMLTransform_callback(SoVRMLTransform self, SoCallbackAction action)"},
	 { "SoVRMLTransform_getBoundingBox", _wrap_SoVRMLTransform_getBoundingBox, METH_VARARGS, "SoVRMLTransform_getBoundingBox(SoVRMLTransform self, SoGetBoundingBoxAction action)"},
	 { "SoVRMLTransform_getMatrix", _wrap_SoVRMLTransform_getMatrix, METH_VARARGS, "SoVRMLTransform_getMatrix(SoVRMLTransform self, SoGetMatrixAction action)"},
	 { "SoVRMLTransform_rayPick", _wrap_SoVRMLTransform_rayPick, METH_VARARGS, "SoVRMLTransform_rayPick(SoVRMLTransform self, SoRayPickAction action)"},
	 { "SoVRMLTransform_getPrimitiveCount", _wrap_SoVRMLTransform_getPrimitiveCount, METH_VARARGS, "SoVRMLTransform_getPrimitiveCount(SoVRMLTransform self, SoGetPrimitiveCountAction action)"},
	 { "SoVRMLTransform_audioRender", _wrap_SoVRMLTransform_audioRender, METH_VARARGS, "SoVRMLTransform_audioRender(SoVRMLTransform self, SoAudioRenderAction action)"},
	 { "SoVRMLTransform_GLRenderBelowPath", _wrap_SoVRMLTransform_GLRenderBelowPath, METH_VARARGS, "SoVRMLTransform_GLRenderBelowPath(SoVRMLTransform self, SoGLRenderAction action)"},
	 { "SoVRMLTransform_GLRenderInPath", _wrap_SoVRMLTransform_GLRenderInPath, METH_VARARGS, "SoVRMLTransform_GLRenderInPath(SoVRMLTransform self, SoGLRenderAction action)"},
	 { "SoVRMLTransform_notify", _wrap_SoVRMLTransform_notify, METH_VARARGS, "SoVRMLTransform_notify(SoVRMLTransform self, SoNotList list)"},
	 { "SoVRMLTransform_swigregister", SoVRMLTransform_swigregister, METH_O, NULL},
	 { "SoVRMLTransform_swiginit", SoVRMLTransform_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLViewpoint_getClassTypeId", _wrap_SoVRMLViewpoint_getClassTypeId, METH_NOARGS, "SoVRMLViewpoint_getClassTypeId() -> SoType"},
	 { "SoVRMLViewpoint_getTypeId", _wrap_SoVRMLViewpoint_getTypeId, METH_O, "SoVRMLViewpoint_getTypeId(SoVRMLViewpoint self) -> SoType"},
	 { "SoVRMLViewpoint_initClass", _wrap_SoVRMLViewpoint_initClass, METH_NOARGS, "SoVRMLViewpoint_initClass()"},
	 { "new_SoVRMLViewpoint", _wrap_new_SoVRMLViewpoint, METH_NOARGS, "new_SoVRMLViewpoint() -> SoVRMLViewpoint"},
	 { "SoVRMLViewpoint_position_set", _wrap_SoVRMLViewpoint_position_set, METH_VARARGS, "SoVRMLViewpoint_position_set(SoVRMLViewpoint self, SoSFVec3f position)"},
	 { "SoVRMLViewpoint_position_get", _wrap_SoVRMLViewpoint_position_get, METH_O, "SoVRMLViewpoint_position_get(SoVRMLViewpoint self) -> SoSFVec3f"},
	 { "SoVRMLViewpoint_orientation_set", _wrap_SoVRMLViewpoint_orientation_set, METH_VARARGS, "SoVRMLViewpoint_orientation_set(SoVRMLViewpoint self, SoSFRotation orientation)"},
	 { "SoVRMLViewpoint_orientation_get", _wrap_SoVRMLViewpoint_orientation_get, METH_O, "SoVRMLViewpoint_orientation_get(SoVRMLViewpoint self) -> SoSFRotation"},
	 { "SoVRMLViewpoint_fieldOfView_set", _wrap_SoVRMLViewpoint_fieldOfView_set, METH_VARARGS, "SoVRMLViewpoint_fieldOfView_set(SoVRMLViewpoint self, SoSFFloat fieldOfView)"},
	 { "SoVRMLViewpoint_fieldOfView_get", _wrap_SoVRMLViewpoint_fieldOfView_get, METH_O, "SoVRMLViewpoint_fieldOfView_get(SoVRMLViewpoint self) -> SoSFFloat"},
	 { "SoVRMLViewpoint_description_set", _wrap_SoVRMLViewpoint_description_set, METH_VARARGS, "SoVRMLViewpoint_description_set(SoVRMLViewpoint self, SoSFString description)"},
	 { "SoVRMLViewpoint_description_get", _wrap_SoVRMLViewpoint_description_get, METH_O, "SoVRMLViewpoint_description_get(SoVRMLViewpoint self) -> SoSFString"},
	 { "SoVRMLViewpoint_jump_set", _wrap_SoVRMLViewpoint_jump_set, METH_VARARGS, "SoVRMLViewpoint_jump_set(SoVRMLViewpoint self, SoSFBool jump)"},
	 { "SoVRMLViewpoint_jump_get", _wrap_SoVRMLViewpoint_jump_get, METH_O, "SoVRMLViewpoint_jump_get(SoVRMLViewpoint self) -> SoSFBool"},
	 { "SoVRMLViewpoint_GLRender", _wrap_SoVRMLViewpoint_GLRender, METH_VARARGS, "SoVRMLViewpoint_GLRender(SoVRMLViewpoint self, SoGLRenderAction action)"},
	 { "SoVRMLViewpoint_swigregister", SoVRMLViewpoint_swigregister, METH_O, NULL},
	 { "SoVRMLViewpoint_swiginit", SoVRMLViewpoint_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLVisibilitySensor_getClassTypeId", _wrap_SoVRMLVisibilitySensor_getClassTypeId, METH_NOARGS, "SoVRMLVisibilitySensor_getClassTypeId() -> SoType"},
	 { "SoVRMLVisibilitySensor_getTypeId", _wrap_SoVRMLVisibilitySensor_getTypeId, METH_O, "SoVRMLVisibilitySensor_getTypeId(SoVRMLVisibilitySensor self) -> SoType"},
	 { "SoVRMLVisibilitySensor_initClass", _wrap_SoVRMLVisibilitySensor_initClass, METH_NOARGS, "SoVRMLVisibilitySensor_initClass()"},
	 { "new_SoVRMLVisibilitySensor", _wrap_new_SoVRMLVisibilitySensor, METH_NOARGS, "new_SoVRMLVisibilitySensor() -> SoVRMLVisibilitySensor"},
	 { "SoVRMLVisibilitySensor_center_set", _wrap_SoVRMLVisibilitySensor_center_set, METH_VARARGS, "SoVRMLVisibilitySensor_center_set(SoVRMLVisibilitySensor self, SoSFVec3f center)"},
	 { "SoVRMLVisibilitySensor_center_get", _wrap_SoVRMLVisibilitySensor_center_get, METH_O, "SoVRMLVisibilitySensor_center_get(SoVRMLVisibilitySensor self) -> SoSFVec3f"},
	 { "SoVRMLVisibilitySensor_size_set", _wrap_SoVRMLVisibilitySensor_size_set, METH_VARARGS, "SoVRMLVisibilitySensor_size_set(SoVRMLVisibilitySensor self, SoSFVec3f size)"},
	 { "SoVRMLVisibilitySensor_size_get", _wrap_SoVRMLVisibilitySensor_size_get, METH_O, "SoVRMLVisibilitySensor_size_get(SoVRMLVisibilitySensor self) -> SoSFVec3f"},
	 { "SoVRMLVisibilitySensor_enabled_set", _wrap_SoVRMLVisibilitySensor_enabled_set, METH_VARARGS, "SoVRMLVisibilitySensor_enabled_set(SoVRMLVisibilitySensor self, SoSFBool enabled)"},
	 { "SoVRMLVisibilitySensor_enabled_get", _wrap_SoVRMLVisibilitySensor_enabled_get, METH_O, "SoVRMLVisibilitySensor_enabled_get(SoVRMLVisibilitySensor self) -> SoSFBool"},
	 { "SoVRMLVisibilitySensor_enterTime_set", _wrap_SoVRMLVisibilitySensor_enterTime_set, METH_VARARGS, "SoVRMLVisibilitySensor_enterTime_set(SoVRMLVisibilitySensor self, SoSFTime enterTime)"},
	 { "SoVRMLVisibilitySensor_enterTime_get", _wrap_SoVRMLVisibilitySensor_enterTime_get, METH_O, "SoVRMLVisibilitySensor_enterTime_get(SoVRMLVisibilitySensor self) -> SoSFTime"},
	 { "SoVRMLVisibilitySensor_exitTime_set", _wrap_SoVRMLVisibilitySensor_exitTime_set, METH_VARARGS, "SoVRMLVisibilitySensor_exitTime_set(SoVRMLVisibilitySensor self, SoSFTime exitTime)"},
	 { "SoVRMLVisibilitySensor_exitTime_get", _wrap_SoVRMLVisibilitySensor_exitTime_get, METH_O, "SoVRMLVisibilitySensor_exitTime_get(SoVRMLVisibilitySensor self) -> SoSFTime"},
	 { "SoVRMLVisibilitySensor_isActive_set", _wrap_SoVRMLVisibilitySensor_isActive_set, METH_VARARGS, "SoVRMLVisibilitySensor_isActive_set(SoVRMLVisibilitySensor self, SoSFBool isActive)"},
	 { "SoVRMLVisibilitySensor_isActive_get", _wrap_SoVRMLVisibilitySensor_isActive_get, METH_O, "SoVRMLVisibilitySensor_isActive_get(SoVRMLVisibilitySensor self) -> SoSFBool"},
	 { "SoVRMLVisibilitySensor_GLRender", _wrap_SoVRMLVisibilitySensor_GLRender, METH_VARARGS, "SoVRMLVisibilitySensor_GLRender(SoVRMLVisibilitySensor self, SoGLRenderAction action)"},
	 { "SoVRMLVisibilitySensor_swigregister", SoVRMLVisibilitySensor_swigregister, METH_O, NULL},
	 { "SoVRMLVisibilitySensor_swiginit", SoVRMLVisibilitySensor_swiginit, METH_VARARGS, NULL},
	 { "SoVRMLWorldInfo_getClassTypeId", _wrap_SoVRMLWorldInfo_getClassTypeId, METH_NOARGS, "SoVRMLWorldInfo_getClassTypeId() -> SoType"},
	 { "SoVRMLWorldInfo_getTypeId", _wrap_SoVRMLWorldInfo_getTypeId, METH_O, "SoVRMLWorldInfo_getTypeId(SoVRMLWorldInfo self) -> SoType"},
	 { "SoVRMLWorldInfo_initClass", _wrap_SoVRMLWorldInfo_initClass, METH_NOARGS, "SoVRMLWorldInfo_initClass()"},
	 { "new_SoVRMLWorldInfo", _wrap_new_SoVRMLWorldInfo, METH_NOARGS, "new_SoVRMLWorldInfo() -> SoVRMLWorldInfo"},
	 { "SoVRMLWorldInfo_title_set", _wrap_SoVRMLWorldInfo_title_set, METH_VARARGS, "SoVRMLWorldInfo_title_set(SoVRMLWorldInfo self, SoSFString title)"},
	 { "SoVRMLWorldInfo_title_get", _wrap_SoVRMLWorldInfo_title_get, METH_O, "SoVRMLWorldInfo_title_get(SoVRMLWorldInfo self) -> SoSFString"},
	 { "SoVRMLWorldInfo_info_set", _wrap_SoVRMLWorldInfo_info_set, METH_VARARGS, "SoVRMLWorldInfo_info_set(SoVRMLWorldInfo self, SoMFString info)"},
	 { "SoVRMLWorldInfo_info_get", _wrap_SoVRMLWorldInfo_info_get, METH_O, "SoVRMLWorldInfo_info_get(SoVRMLWorldInfo self) -> SoMFString"},
	 { "SoVRMLWorldInfo_swigregister", SoVRMLWorldInfo_swigregister, METH_O, NULL},
	 { "SoVRMLWorldInfo_swiginit", SoVRMLWorldInfo_swiginit, METH_VARARGS, NULL},
	 { "new_SoEventManager", _wrap_new_SoEventManager, METH_NOARGS, "new_SoEventManager() -> SoEventManager"},
	 { "delete_SoEventManager", _wrap_delete_SoEventManager, METH_O, "delete_SoEventManager(SoEventManager self)"},
	 { "SoEventManager_setSceneGraph", _wrap_SoEventManager_setSceneGraph, METH_VARARGS, "SoEventManager_setSceneGraph(SoEventManager self, SoNode sceneroot)"},
	 { "SoEventManager_getSceneGraph", _wrap_SoEventManager_getSceneGraph, METH_O, "SoEventManager_getSceneGraph(SoEventManager self) -> SoNode"},
	 { "SoEventManager_setCamera", _wrap_SoEventManager_setCamera, METH_VARARGS, "SoEventManager_setCamera(SoEventManager self, SoCamera camera)"},
	 { "SoEventManager_getCamera", _wrap_SoEventManager_getCamera, METH_O, "SoEventManager_getCamera(SoEventManager self) -> SoCamera"},
	 { "SoEventManager_processEvent", _wrap_SoEventManager_processEvent, METH_VARARGS, "SoEventManager_processEvent(SoEventManager self, SoEvent event) -> SbBool"},
	 { "SoEventManager_setNavigationState", _wrap_SoEventManager_setNavigationState, METH_VARARGS, "SoEventManager_setNavigationState(SoEventManager self, SoEventManager::NavigationState state)"},
	 { "SoEventManager_getNavigationState", _wrap_SoEventManager_getNavigationState, METH_O, "SoEventManager_getNavigationState(SoEventManager self) -> SoEventManager::NavigationState"},
	 { "SoEventManager_getNumSoScXMLStateMachines", _wrap_SoEventManager_getNumSoScXMLStateMachines, METH_O, "SoEventManager_getNumSoScXMLStateMachines(SoEventManager self) -> int"},
	 { "SoEventManager_getSoScXMLStateMachine", _wrap_SoEventManager_getSoScXMLStateMachine, METH_VARARGS, "SoEventManager_getSoScXMLStateMachine(SoEventManager self, int idx) -> SoScXMLStateMachine"},
	 { "SoEventManager_addSoScXMLStateMachine", _wrap_SoEventManager_addSoScXMLStateMachine, METH_VARARGS, "SoEventManager_addSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"},
	 { "SoEventManager_removeSoScXMLStateMachine", _wrap_SoEventManager_removeSoScXMLStateMachine, METH_VARARGS, "SoEventManager_removeSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"},
	 { "SoEventManager_setSize", _wrap_SoEventManager_setSize, METH_VARARGS, "SoEventManager_setSize(SoEventManager self, SbVec2s newsize)"},
	 { "SoEventManager_setOrigin", _wrap_SoEventManager_setOrigin, METH_VARARGS, "SoEventManager_setOrigin(SoEventManager self, SbVec2s newOrigin)"},
	 { "SoEventManager_setViewportRegion", _wrap_SoEventManager_setViewportRegion, METH_VARARGS, "SoEventManager_setViewportRegion(SoEventManager self, SbViewportRegion newregion)"},
	 { "SoEventManager_getViewportRegion", _wrap_SoEventManager_getViewportRegion, METH_O, "SoEventManager_getViewportRegion(SoEventManager self) -> SbViewportRegion"},
	 { "SoEventManager_setHandleEventAction", _wrap_SoEventManager_setHandleEventAction, METH_VARARGS, "SoEventManager_setHandleEventAction(SoEventManager self, SoHandleEventAction hea)"},
	 { "SoEventManager_getHandleEventAction", _wrap_SoEventManager_getHandleEventAction, METH_O, "SoEventManager_getHandleEventAction(SoEventManager self) -> SoHandleEventAction"},
	 { "SoEventManager_swigregister", SoEventManager_swigregister, METH_O, NULL},
	 { "SoEventManager_swiginit", SoEventManager_swiginit, METH_VARARGS, NULL},
	 { "new_SoRenderManager", _wrap_new_SoRenderManager, METH_NOARGS, "new_SoRenderManager() -> SoRenderManager"},
	 { "delete_SoRenderManager", _wrap_delete_SoRenderManager, METH_O, "delete_SoRenderManager(SoRenderManager self)"},
	 { "SoRenderManager_render", _wrap_SoRenderManager_render, METH_VARARGS, "\n"
		"SoRenderManager_render(SoRenderManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)\n"
		"SoRenderManager_render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)\n"
		""},
	 { "SoRenderManager_addSuperimposition", _wrap_SoRenderManager_addSuperimposition, METH_VARARGS, "SoRenderManager_addSuperimposition(SoRenderManager self, SoNode scene, uint32_t flags=SoRenderManager::Superimposition::AUTOREDRAW|SoRenderManager::Superimposition::ZBUFFERON|SoRenderManager::Superimposition::CLEARZBUFFER) -> SoRenderManager::Superimposition"},
	 { "SoRenderManager_removeSuperimposition", _wrap_SoRenderManager_removeSuperimposition, METH_VARARGS, "SoRenderManager_removeSuperimposition(SoRenderManager self, SoRenderManager::Superimposition * s)"},
	 { "SoRenderManager_setSceneGraph", _wrap_SoRenderManager_setSceneGraph, METH_VARARGS, "SoRenderManager_setSceneGraph(SoRenderManager self, SoNode sceneroot)"},
	 { "SoRenderManager_getSceneGraph", _wrap_SoRenderManager_getSceneGraph, METH_O, "SoRenderManager_getSceneGraph(SoRenderManager self) -> SoNode"},
	 { "SoRenderManager_setCamera", _wrap_SoRenderManager_setCamera, METH_VARARGS, "SoRenderManager_setCamera(SoRenderManager self, SoCamera camera)"},
	 { "SoRenderManager_getCamera", _wrap_SoRenderManager_getCamera, METH_O, "SoRenderManager_getCamera(SoRenderManager self) -> SoCamera"},
	 { "SoRenderManager_setAutoClipping", _wrap_SoRenderManager_setAutoClipping, METH_VARARGS, "SoRenderManager_setAutoClipping(SoRenderManager self, SoRenderManager::AutoClippingStrategy autoclipping)"},
	 { "SoRenderManager_getAutoClipping", _wrap_SoRenderManager_getAutoClipping, METH_O, "SoRenderManager_getAutoClipping(SoRenderManager self) -> SoRenderManager::AutoClippingStrategy"},
	 { "SoRenderManager_setNearPlaneValue", _wrap_SoRenderManager_setNearPlaneValue, METH_VARARGS, "SoRenderManager_setNearPlaneValue(SoRenderManager self, float value)"},
	 { "SoRenderManager_getNearPlaneValue", _wrap_SoRenderManager_getNearPlaneValue, METH_O, "SoRenderManager_getNearPlaneValue(SoRenderManager self) -> float"},
	 { "SoRenderManager_setTexturesEnabled", _wrap_SoRenderManager_setTexturesEnabled, METH_VARARGS, "SoRenderManager_setTexturesEnabled(SoRenderManager self, SbBool const onoff)"},
	 { "SoRenderManager_isTexturesEnabled", _wrap_SoRenderManager_isTexturesEnabled, METH_O, "SoRenderManager_isTexturesEnabled(SoRenderManager self) -> SbBool"},
	 { "SoRenderManager_setDoubleBuffer", _wrap_SoRenderManager_setDoubleBuffer, METH_VARARGS, "SoRenderManager_setDoubleBuffer(SoRenderManager self, SbBool const enable)"},
	 { "SoRenderManager_isDoubleBuffer", _wrap_SoRenderManager_isDoubleBuffer, METH_O, "SoRenderManager_isDoubleBuffer(SoRenderManager self) -> SbBool"},
	 { "SoRenderManager_setRenderMode", _wrap_SoRenderManager_setRenderMode, METH_VARARGS, "SoRenderManager_setRenderMode(SoRenderManager self, SoRenderManager::RenderMode const mode)"},
	 { "SoRenderManager_getRenderMode", _wrap_SoRenderManager_getRenderMode, METH_O, "SoRenderManager_getRenderMode(SoRenderManager self) -> SoRenderManager::RenderMode"},
	 { "SoRenderManager_setStereoMode", _wrap_SoRenderManager_setStereoMode, METH_VARARGS, "SoRenderManager_setStereoMode(SoRenderManager self, SoRenderManager::StereoMode const mode)"},
	 { "SoRenderManager_getStereoMode", _wrap_SoRenderManager_getStereoMode, METH_O, "SoRenderManager_getStereoMode(SoRenderManager self) -> SoRenderManager::StereoMode"},
	 { "SoRenderManager_setStereoOffset", _wrap_SoRenderManager_setStereoOffset, METH_VARARGS, "SoRenderManager_setStereoOffset(SoRenderManager self, float const offset)"},
	 { "SoRenderManager_getStereoOffset", _wrap_SoRenderManager_getStereoOffset, METH_O, "SoRenderManager_getStereoOffset(SoRenderManager self) -> float"},
	 { "SoRenderManager_isAutoRedraw", _wrap_SoRenderManager_isAutoRedraw, METH_O, "SoRenderManager_isAutoRedraw(SoRenderManager self) -> SbBool"},
	 { "SoRenderManager_setRedrawPriority", _wrap_SoRenderManager_setRedrawPriority, METH_VARARGS, "SoRenderManager_setRedrawPriority(SoRenderManager self, uint32_t const priority)"},
	 { "SoRenderManager_getRedrawPriority", _wrap_SoRenderManager_getRedrawPriority, METH_O, "SoRenderManager_getRedrawPriority(SoRenderManager self) -> uint32_t"},
	 { "SoRenderManager_scheduleRedraw", _wrap_SoRenderManager_scheduleRedraw, METH_O, "SoRenderManager_scheduleRedraw(SoRenderManager self)"},
	 { "SoRenderManager_setWindowSize", _wrap_SoRenderManager_setWindowSize, METH_VARARGS, "SoRenderManager_setWindowSize(SoRenderManager self, SbVec2s newsize)"},
	 { "SoRenderManager_getWindowSize", _wrap_SoRenderManager_getWindowSize, METH_O, "SoRenderManager_getWindowSize(SoRenderManager self) -> SbVec2s"},
	 { "SoRenderManager_setSize", _wrap_SoRenderManager_setSize, METH_VARARGS, "SoRenderManager_setSize(SoRenderManager self, SbVec2s newsize)"},
	 { "SoRenderManager_getSize", _wrap_SoRenderManager_getSize, METH_O, "SoRenderManager_getSize(SoRenderManager self) -> SbVec2s"},
	 { "SoRenderManager_setOrigin", _wrap_SoRenderManager_setOrigin, METH_VARARGS, "SoRenderManager_setOrigin(SoRenderManager self, SbVec2s newOrigin)"},
	 { "SoRenderManager_getOrigin", _wrap_SoRenderManager_getOrigin, METH_O, "SoRenderManager_getOrigin(SoRenderManager self) -> SbVec2s"},
	 { "SoRenderManager_setViewportRegion", _wrap_SoRenderManager_setViewportRegion, METH_VARARGS, "SoRenderManager_setViewportRegion(SoRenderManager self, SbViewportRegion newRegion)"},
	 { "SoRenderManager_getViewportRegion", _wrap_SoRenderManager_getViewportRegion, METH_O, "SoRenderManager_getViewportRegion(SoRenderManager self) -> SbViewportRegion"},
	 { "SoRenderManager_setBackgroundColor", _wrap_SoRenderManager_setBackgroundColor, METH_VARARGS, "SoRenderManager_setBackgroundColor(SoRenderManager self, SbColor4f color)"},
	 { "SoRenderManager_getBackgroundColor", _wrap_SoRenderManager_getBackgroundColor, METH_O, "SoRenderManager_getBackgroundColor(SoRenderManager self) -> SbColor4f"},
	 { "SoRenderManager_setOverlayColor", _wrap_SoRenderManager_setOverlayColor, METH_VARARGS, "SoRenderManager_setOverlayColor(SoRenderManager self, SbColor4f color)"},
	 { "SoRenderManager_getOverlayColor", _wrap_SoRenderManager_getOverlayColor, METH_O, "SoRenderManager_getOverlayColor(SoRenderManager self) -> SbColor4f"},
	 { "SoRenderManager_setBackgroundIndex", _wrap_SoRenderManager_setBackgroundIndex, METH_VARARGS, "SoRenderManager_setBackgroundIndex(SoRenderManager self, int const index)"},
	 { "SoRenderManager_getBackgroundIndex", _wrap_SoRenderManager_getBackgroundIndex, METH_O, "SoRenderManager_getBackgroundIndex(SoRenderManager self) -> int"},
	 { "SoRenderManager_setRGBMode", _wrap_SoRenderManager_setRGBMode, METH_VARARGS, "SoRenderManager_setRGBMode(SoRenderManager self, SbBool const onOrOff)"},
	 { "SoRenderManager_isRGBMode", _wrap_SoRenderManager_isRGBMode, METH_O, "SoRenderManager_isRGBMode(SoRenderManager self) -> SbBool"},
	 { "SoRenderManager_activate", _wrap_SoRenderManager_activate, METH_O, "SoRenderManager_activate(SoRenderManager self)"},
	 { "SoRenderManager_deactivate", _wrap_SoRenderManager_deactivate, METH_O, "SoRenderManager_deactivate(SoRenderManager self)"},
	 { "SoRenderManager_setAntialiasing", _wrap_SoRenderManager_setAntialiasing, METH_VARARGS, "SoRenderManager_setAntialiasing(SoRenderManager self, SbBool const smoothing, int const numPasses)"},
	 { "SoRenderManager_getAntialiasing", _wrap_SoRenderManager_getAntialiasing, METH_VARARGS, "SoRenderManager_getAntialiasing(SoRenderManager self, SbBool & smoothing, int & numPasses)"},
	 { "SoRenderManager_setGLRenderAction", _wrap_SoRenderManager_setGLRenderAction, METH_VARARGS, "SoRenderManager_setGLRenderAction(SoRenderManager self, SoGLRenderAction action)"},
	 { "SoRenderManager_getGLRenderAction", _wrap_SoRenderManager_getGLRenderAction, METH_O, "SoRenderManager_getGLRenderAction(SoRenderManager self) -> SoGLRenderAction"},
	 { "SoRenderManager_setAudioRenderAction", _wrap_SoRenderManager_setAudioRenderAction, METH_VARARGS, "SoRenderManager_setAudioRenderAction(SoRenderManager self, SoAudioRenderAction action)"},
	 { "SoRenderManager_getAudioRenderAction", _wrap_SoRenderManager_getAudioRenderAction, METH_O, "SoRenderManager_getAudioRenderAction(SoRenderManager self) -> SoAudioRenderAction"},
	 { "SoRenderManager_enableRealTimeUpdate", _wrap_SoRenderManager_enableRealTimeUpdate, METH_O, "SoRenderManager_enableRealTimeUpdate(SbBool const flag)"},
	 { "SoRenderManager_isRealTimeUpdateEnabled", _wrap_SoRenderManager_isRealTimeUpdateEnabled, METH_NOARGS, "SoRenderManager_isRealTimeUpdateEnabled() -> SbBool"},
	 { "SoRenderManager_getDefaultRedrawPriority", _wrap_SoRenderManager_getDefaultRedrawPriority, METH_NOARGS, "SoRenderManager_getDefaultRedrawPriority() -> uint32_t"},
	 { "SoRenderManager_reinitialize", _wrap_SoRenderManager_reinitialize, METH_O, "SoRenderManager_reinitialize(SoRenderManager self)"},
	 { "SoRenderManager_setRenderCallback", _wrap_SoRenderManager_setRenderCallback, METH_VARARGS, "\n"
		"SoRenderManager_setRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * f, void *const userData=None)\n"
		"SoRenderManager_setRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * userData=None)\n"
		""},
	 { "SoRenderManager_addPreRenderCallback", _wrap_SoRenderManager_addPreRenderCallback, METH_VARARGS, "\n"
		"SoRenderManager_addPreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)\n"
		"SoRenderManager_addPreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)\n"
		""},
	 { "SoRenderManager_removePreRenderCallback", _wrap_SoRenderManager_removePreRenderCallback, METH_VARARGS, "\n"
		"SoRenderManager_removePreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)\n"
		"SoRenderManager_removePreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)\n"
		""},
	 { "SoRenderManager_addPostRenderCallback", _wrap_SoRenderManager_addPostRenderCallback, METH_VARARGS, "\n"
		"SoRenderManager_addPostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)\n"
		"SoRenderManager_addPostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)\n"
		""},
	 { "SoRenderManager_removePostRenderCallback", _wrap_SoRenderManager_removePostRenderCallback, METH_VARARGS, "\n"
		"SoRenderManager_removePostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)\n"
		"SoRenderManager_removePostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)\n"
		""},
	 { "SoRenderManager_swigregister", SoRenderManager_swigregister, METH_O, NULL},
	 { "SoRenderManager_swiginit", SoRenderManager_swiginit, METH_VARARGS, NULL},
	 { "ScXMLObject_getClassTypeId", _wrap_ScXMLObject_getClassTypeId, METH_NOARGS, "ScXMLObject_getClassTypeId() -> SoType"},
	 { "ScXMLObject_getTypeId", _wrap_ScXMLObject_getTypeId, METH_O, "ScXMLObject_getTypeId(ScXMLObject self) -> SoType"},
	 { "ScXMLObject_initClass", _wrap_ScXMLObject_initClass, METH_NOARGS, "ScXMLObject_initClass()"},
	 { "ScXMLObject_cleanClass", _wrap_ScXMLObject_cleanClass, METH_NOARGS, "ScXMLObject_cleanClass()"},
	 { "delete_ScXMLObject", _wrap_delete_ScXMLObject, METH_O, "delete_ScXMLObject(ScXMLObject self)"},
	 { "ScXMLObject_isOfType", _wrap_ScXMLObject_isOfType, METH_VARARGS, "ScXMLObject_isOfType(ScXMLObject self, SoType type) -> SbBool"},
	 { "ScXMLObject_swigregister", ScXMLObject_swigregister, METH_O, NULL},
	 { "ScXMLEventTarget_getClassTypeId", _wrap_ScXMLEventTarget_getClassTypeId, METH_NOARGS, "ScXMLEventTarget_getClassTypeId() -> SoType"},
	 { "ScXMLEventTarget_getTypeId", _wrap_ScXMLEventTarget_getTypeId, METH_O, "ScXMLEventTarget_getTypeId(ScXMLEventTarget self) -> SoType"},
	 { "ScXMLEventTarget_initClass", _wrap_ScXMLEventTarget_initClass, METH_NOARGS, "ScXMLEventTarget_initClass()"},
	 { "ScXMLEventTarget_cleanClass", _wrap_ScXMLEventTarget_cleanClass, METH_NOARGS, "ScXMLEventTarget_cleanClass()"},
	 { "delete_ScXMLEventTarget", _wrap_delete_ScXMLEventTarget, METH_O, "delete_ScXMLEventTarget(ScXMLEventTarget self)"},
	 { "ScXMLEventTarget_setEventTargetType", _wrap_ScXMLEventTarget_setEventTargetType, METH_VARARGS, "ScXMLEventTarget_setEventTargetType(ScXMLEventTarget self, char const * targettype)"},
	 { "ScXMLEventTarget_getEventTargetType", _wrap_ScXMLEventTarget_getEventTargetType, METH_O, "ScXMLEventTarget_getEventTargetType(ScXMLEventTarget self) -> char const *"},
	 { "ScXMLEventTarget_setEventTargetName", _wrap_ScXMLEventTarget_setEventTargetName, METH_VARARGS, "ScXMLEventTarget_setEventTargetName(ScXMLEventTarget self, char const * targetname)"},
	 { "ScXMLEventTarget_getEventTargetName", _wrap_ScXMLEventTarget_getEventTargetName, METH_O, "ScXMLEventTarget_getEventTargetName(ScXMLEventTarget self) -> char const *"},
	 { "ScXMLEventTarget_getCurrentEvent", _wrap_ScXMLEventTarget_getCurrentEvent, METH_O, "ScXMLEventTarget_getCurrentEvent(ScXMLEventTarget self) -> ScXMLEvent"},
	 { "ScXMLEventTarget_queueEvent", _wrap_ScXMLEventTarget_queueEvent, METH_VARARGS, "\n"
		"ScXMLEventTarget_queueEvent(ScXMLEventTarget self, ScXMLEvent event)\n"
		"ScXMLEventTarget_queueEvent(ScXMLEventTarget self, SbName eventid)\n"
		""},
	 { "ScXMLEventTarget_processEventQueue", _wrap_ScXMLEventTarget_processEventQueue, METH_O, "ScXMLEventTarget_processEventQueue(ScXMLEventTarget self) -> SbBool"},
	 { "ScXMLEventTarget_sendExternalEvent", _wrap_ScXMLEventTarget_sendExternalEvent, METH_VARARGS, "ScXMLEventTarget_sendExternalEvent(ScXMLEventTarget self, ScXMLSendElt sendelt) -> SbBool"},
	 { "ScXMLEventTarget_sendInternalEvent", _wrap_ScXMLEventTarget_sendInternalEvent, METH_VARARGS, "ScXMLEventTarget_sendInternalEvent(ScXMLEventTarget self, ScXMLEventElt sendelt) -> SbBool"},
	 { "ScXMLEventTarget_queueInternalEvent", _wrap_ScXMLEventTarget_queueInternalEvent, METH_VARARGS, "\n"
		"ScXMLEventTarget_queueInternalEvent(ScXMLEventTarget self, ScXMLEvent event)\n"
		"ScXMLEventTarget_queueInternalEvent(ScXMLEventTarget self, SbName eventid)\n"
		""},
	 { "ScXMLEventTarget_swigregister", ScXMLEventTarget_swigregister, METH_O, NULL},
	 { "SoScXMLNavigationTarget_getClassTypeId", _wrap_SoScXMLNavigationTarget_getClassTypeId, METH_NOARGS, "SoScXMLNavigationTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLNavigationTarget_getTypeId", _wrap_SoScXMLNavigationTarget_getTypeId, METH_O, "SoScXMLNavigationTarget_getTypeId(SoScXMLNavigationTarget self) -> SoType"},
	 { "SoScXMLNavigationTarget_initClass", _wrap_SoScXMLNavigationTarget_initClass, METH_NOARGS, "SoScXMLNavigationTarget_initClass()"},
	 { "SoScXMLNavigationTarget_cleanClass", _wrap_SoScXMLNavigationTarget_cleanClass, METH_NOARGS, "SoScXMLNavigationTarget_cleanClass()"},
	 { "SoScXMLNavigationTarget_swigregister", SoScXMLNavigationTarget_swigregister, METH_O, NULL},
	 { "SoScXMLDollyTarget_getClassTypeId", _wrap_SoScXMLDollyTarget_getClassTypeId, METH_NOARGS, "SoScXMLDollyTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLDollyTarget_getTypeId", _wrap_SoScXMLDollyTarget_getTypeId, METH_O, "SoScXMLDollyTarget_getTypeId(SoScXMLDollyTarget self) -> SoType"},
	 { "SoScXMLDollyTarget_createInstance", _wrap_SoScXMLDollyTarget_createInstance, METH_NOARGS, "SoScXMLDollyTarget_createInstance() -> void *"},
	 { "SoScXMLDollyTarget_initClass", _wrap_SoScXMLDollyTarget_initClass, METH_NOARGS, "SoScXMLDollyTarget_initClass()"},
	 { "SoScXMLDollyTarget_cleanClass", _wrap_SoScXMLDollyTarget_cleanClass, METH_NOARGS, "SoScXMLDollyTarget_cleanClass()"},
	 { "SoScXMLDollyTarget_constructSingleton", _wrap_SoScXMLDollyTarget_constructSingleton, METH_NOARGS, "SoScXMLDollyTarget_constructSingleton() -> SoScXMLDollyTarget"},
	 { "SoScXMLDollyTarget_destructSingleton", _wrap_SoScXMLDollyTarget_destructSingleton, METH_NOARGS, "SoScXMLDollyTarget_destructSingleton()"},
	 { "SoScXMLDollyTarget_singleton", _wrap_SoScXMLDollyTarget_singleton, METH_NOARGS, "SoScXMLDollyTarget_singleton() -> SoScXMLDollyTarget"},
	 { "SoScXMLDollyTarget_BEGIN", _wrap_SoScXMLDollyTarget_BEGIN, METH_NOARGS, "SoScXMLDollyTarget_BEGIN() -> SbName"},
	 { "SoScXMLDollyTarget_UPDATE", _wrap_SoScXMLDollyTarget_UPDATE, METH_NOARGS, "SoScXMLDollyTarget_UPDATE() -> SbName"},
	 { "SoScXMLDollyTarget_END", _wrap_SoScXMLDollyTarget_END, METH_NOARGS, "SoScXMLDollyTarget_END() -> SbName"},
	 { "SoScXMLDollyTarget_JUMP", _wrap_SoScXMLDollyTarget_JUMP, METH_NOARGS, "SoScXMLDollyTarget_JUMP() -> SbName"},
	 { "SoScXMLDollyTarget_STEP_IN", _wrap_SoScXMLDollyTarget_STEP_IN, METH_NOARGS, "SoScXMLDollyTarget_STEP_IN() -> SbName"},
	 { "SoScXMLDollyTarget_STEP_OUT", _wrap_SoScXMLDollyTarget_STEP_OUT, METH_NOARGS, "SoScXMLDollyTarget_STEP_OUT() -> SbName"},
	 { "SoScXMLDollyTarget_dolly", _wrap_SoScXMLDollyTarget_dolly, METH_VARARGS, "SoScXMLDollyTarget_dolly(SoCamera camera, float diff)"},
	 { "SoScXMLDollyTarget_jump", _wrap_SoScXMLDollyTarget_jump, METH_VARARGS, "SoScXMLDollyTarget_jump(SoCamera camera, float focaldistance)"},
	 { "SoScXMLDollyTarget_step", _wrap_SoScXMLDollyTarget_step, METH_VARARGS, "SoScXMLDollyTarget_step(SoCamera camera, SbBool exponential, float diff, float min=0.0, float max=0.0)"},
	 { "SoScXMLDollyTarget_swigregister", SoScXMLDollyTarget_swigregister, METH_O, NULL},
	 { "SoScXMLFlightControlTarget_getClassTypeId", _wrap_SoScXMLFlightControlTarget_getClassTypeId, METH_NOARGS, "SoScXMLFlightControlTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLFlightControlTarget_getTypeId", _wrap_SoScXMLFlightControlTarget_getTypeId, METH_O, "SoScXMLFlightControlTarget_getTypeId(SoScXMLFlightControlTarget self) -> SoType"},
	 { "SoScXMLFlightControlTarget_createInstance", _wrap_SoScXMLFlightControlTarget_createInstance, METH_NOARGS, "SoScXMLFlightControlTarget_createInstance() -> void *"},
	 { "SoScXMLFlightControlTarget_initClass", _wrap_SoScXMLFlightControlTarget_initClass, METH_NOARGS, "SoScXMLFlightControlTarget_initClass()"},
	 { "SoScXMLFlightControlTarget_cleanClass", _wrap_SoScXMLFlightControlTarget_cleanClass, METH_NOARGS, "SoScXMLFlightControlTarget_cleanClass()"},
	 { "SoScXMLFlightControlTarget_constructSingleton", _wrap_SoScXMLFlightControlTarget_constructSingleton, METH_NOARGS, "SoScXMLFlightControlTarget_constructSingleton() -> SoScXMLFlightControlTarget"},
	 { "SoScXMLFlightControlTarget_destructSingleton", _wrap_SoScXMLFlightControlTarget_destructSingleton, METH_NOARGS, "SoScXMLFlightControlTarget_destructSingleton()"},
	 { "SoScXMLFlightControlTarget_singleton", _wrap_SoScXMLFlightControlTarget_singleton, METH_NOARGS, "SoScXMLFlightControlTarget_singleton() -> SoScXMLFlightControlTarget"},
	 { "SoScXMLFlightControlTarget_PITCH", _wrap_SoScXMLFlightControlTarget_PITCH, METH_NOARGS, "SoScXMLFlightControlTarget_PITCH() -> SbName"},
	 { "SoScXMLFlightControlTarget_YAW", _wrap_SoScXMLFlightControlTarget_YAW, METH_NOARGS, "SoScXMLFlightControlTarget_YAW() -> SbName"},
	 { "SoScXMLFlightControlTarget_ROLL", _wrap_SoScXMLFlightControlTarget_ROLL, METH_NOARGS, "SoScXMLFlightControlTarget_ROLL() -> SbName"},
	 { "SoScXMLFlightControlTarget_RESET_ROLL", _wrap_SoScXMLFlightControlTarget_RESET_ROLL, METH_NOARGS, "SoScXMLFlightControlTarget_RESET_ROLL() -> SbName"},
	 { "SoScXMLFlightControlTarget_pitch", _wrap_SoScXMLFlightControlTarget_pitch, METH_VARARGS, "SoScXMLFlightControlTarget_pitch(SoCamera camera, float radians)"},
	 { "SoScXMLFlightControlTarget_yaw", _wrap_SoScXMLFlightControlTarget_yaw, METH_VARARGS, "SoScXMLFlightControlTarget_yaw(SoCamera camera, float radians)"},
	 { "SoScXMLFlightControlTarget_roll", _wrap_SoScXMLFlightControlTarget_roll, METH_VARARGS, "SoScXMLFlightControlTarget_roll(SoCamera camera, float radians)"},
	 { "SoScXMLFlightControlTarget_resetRoll", _wrap_SoScXMLFlightControlTarget_resetRoll, METH_VARARGS, "SoScXMLFlightControlTarget_resetRoll(SoCamera camera, SbVec3f upvector)"},
	 { "SoScXMLFlightControlTarget_swigregister", SoScXMLFlightControlTarget_swigregister, METH_O, NULL},
	 { "SoScXMLMiscTarget_getClassTypeId", _wrap_SoScXMLMiscTarget_getClassTypeId, METH_NOARGS, "SoScXMLMiscTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLMiscTarget_getTypeId", _wrap_SoScXMLMiscTarget_getTypeId, METH_O, "SoScXMLMiscTarget_getTypeId(SoScXMLMiscTarget self) -> SoType"},
	 { "SoScXMLMiscTarget_createInstance", _wrap_SoScXMLMiscTarget_createInstance, METH_NOARGS, "SoScXMLMiscTarget_createInstance() -> void *"},
	 { "SoScXMLMiscTarget_initClass", _wrap_SoScXMLMiscTarget_initClass, METH_NOARGS, "SoScXMLMiscTarget_initClass()"},
	 { "SoScXMLMiscTarget_cleanClass", _wrap_SoScXMLMiscTarget_cleanClass, METH_NOARGS, "SoScXMLMiscTarget_cleanClass()"},
	 { "SoScXMLMiscTarget_constructSingleton", _wrap_SoScXMLMiscTarget_constructSingleton, METH_NOARGS, "SoScXMLMiscTarget_constructSingleton() -> SoScXMLMiscTarget"},
	 { "SoScXMLMiscTarget_destructSingleton", _wrap_SoScXMLMiscTarget_destructSingleton, METH_NOARGS, "SoScXMLMiscTarget_destructSingleton()"},
	 { "SoScXMLMiscTarget_singleton", _wrap_SoScXMLMiscTarget_singleton, METH_NOARGS, "SoScXMLMiscTarget_singleton() -> SoScXMLMiscTarget"},
	 { "SoScXMLMiscTarget_VIEW_ALL", _wrap_SoScXMLMiscTarget_VIEW_ALL, METH_NOARGS, "SoScXMLMiscTarget_VIEW_ALL() -> SbName"},
	 { "SoScXMLMiscTarget_REDRAW", _wrap_SoScXMLMiscTarget_REDRAW, METH_NOARGS, "SoScXMLMiscTarget_REDRAW() -> SbName"},
	 { "SoScXMLMiscTarget_POINT_AT", _wrap_SoScXMLMiscTarget_POINT_AT, METH_NOARGS, "SoScXMLMiscTarget_POINT_AT() -> SbName"},
	 { "SoScXMLMiscTarget_SET_FOCAL_DISTANCE", _wrap_SoScXMLMiscTarget_SET_FOCAL_DISTANCE, METH_NOARGS, "SoScXMLMiscTarget_SET_FOCAL_DISTANCE() -> SbName"},
	 { "SoScXMLMiscTarget_SET_CAMERA_POSITION", _wrap_SoScXMLMiscTarget_SET_CAMERA_POSITION, METH_NOARGS, "SoScXMLMiscTarget_SET_CAMERA_POSITION() -> SbName"},
	 { "SoScXMLMiscTarget_swigregister", SoScXMLMiscTarget_swigregister, METH_O, NULL},
	 { "SoScXMLMotionTarget_getClassTypeId", _wrap_SoScXMLMotionTarget_getClassTypeId, METH_NOARGS, "SoScXMLMotionTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLMotionTarget_getTypeId", _wrap_SoScXMLMotionTarget_getTypeId, METH_O, "SoScXMLMotionTarget_getTypeId(SoScXMLMotionTarget self) -> SoType"},
	 { "SoScXMLMotionTarget_createInstance", _wrap_SoScXMLMotionTarget_createInstance, METH_NOARGS, "SoScXMLMotionTarget_createInstance() -> void *"},
	 { "SoScXMLMotionTarget_initClass", _wrap_SoScXMLMotionTarget_initClass, METH_NOARGS, "SoScXMLMotionTarget_initClass()"},
	 { "SoScXMLMotionTarget_cleanClass", _wrap_SoScXMLMotionTarget_cleanClass, METH_NOARGS, "SoScXMLMotionTarget_cleanClass()"},
	 { "SoScXMLMotionTarget_constructSingleton", _wrap_SoScXMLMotionTarget_constructSingleton, METH_NOARGS, "SoScXMLMotionTarget_constructSingleton() -> SoScXMLMotionTarget"},
	 { "SoScXMLMotionTarget_destructSingleton", _wrap_SoScXMLMotionTarget_destructSingleton, METH_NOARGS, "SoScXMLMotionTarget_destructSingleton()"},
	 { "SoScXMLMotionTarget_singleton", _wrap_SoScXMLMotionTarget_singleton, METH_NOARGS, "SoScXMLMotionTarget_singleton() -> SoScXMLMotionTarget"},
	 { "SoScXMLMotionTarget_swigregister", SoScXMLMotionTarget_swigregister, METH_O, NULL},
	 { "SoScXMLNavigation_initClasses", _wrap_SoScXMLNavigation_initClasses, METH_NOARGS, "SoScXMLNavigation_initClasses()"},
	 { "SoScXMLNavigation_cleanClasses", _wrap_SoScXMLNavigation_cleanClasses, METH_NOARGS, "SoScXMLNavigation_cleanClasses()"},
	 { "SoScXMLNavigation_syncLock", _wrap_SoScXMLNavigation_syncLock, METH_NOARGS, "SoScXMLNavigation_syncLock()"},
	 { "SoScXMLNavigation_syncUnlock", _wrap_SoScXMLNavigation_syncUnlock, METH_NOARGS, "SoScXMLNavigation_syncUnlock()"},
	 { "new_SoScXMLNavigation", _wrap_new_SoScXMLNavigation, METH_NOARGS, "new_SoScXMLNavigation() -> SoScXMLNavigation"},
	 { "delete_SoScXMLNavigation", _wrap_delete_SoScXMLNavigation, METH_O, "delete_SoScXMLNavigation(SoScXMLNavigation self)"},
	 { "SoScXMLNavigation_swigregister", SoScXMLNavigation_swigregister, METH_O, NULL},
	 { "SoScXMLNavigation_swiginit", SoScXMLNavigation_swiginit, METH_VARARGS, NULL},
	 { "SoScXMLPanTarget_getClassTypeId", _wrap_SoScXMLPanTarget_getClassTypeId, METH_NOARGS, "SoScXMLPanTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLPanTarget_getTypeId", _wrap_SoScXMLPanTarget_getTypeId, METH_O, "SoScXMLPanTarget_getTypeId(SoScXMLPanTarget self) -> SoType"},
	 { "SoScXMLPanTarget_createInstance", _wrap_SoScXMLPanTarget_createInstance, METH_NOARGS, "SoScXMLPanTarget_createInstance() -> void *"},
	 { "SoScXMLPanTarget_initClass", _wrap_SoScXMLPanTarget_initClass, METH_NOARGS, "SoScXMLPanTarget_initClass()"},
	 { "SoScXMLPanTarget_cleanClass", _wrap_SoScXMLPanTarget_cleanClass, METH_NOARGS, "SoScXMLPanTarget_cleanClass()"},
	 { "SoScXMLPanTarget_constructSingleton", _wrap_SoScXMLPanTarget_constructSingleton, METH_NOARGS, "SoScXMLPanTarget_constructSingleton() -> SoScXMLPanTarget"},
	 { "SoScXMLPanTarget_destructSingleton", _wrap_SoScXMLPanTarget_destructSingleton, METH_NOARGS, "SoScXMLPanTarget_destructSingleton()"},
	 { "SoScXMLPanTarget_singleton", _wrap_SoScXMLPanTarget_singleton, METH_NOARGS, "SoScXMLPanTarget_singleton() -> SoScXMLPanTarget"},
	 { "SoScXMLPanTarget_BEGIN", _wrap_SoScXMLPanTarget_BEGIN, METH_NOARGS, "SoScXMLPanTarget_BEGIN() -> SbName"},
	 { "SoScXMLPanTarget_UPDATE", _wrap_SoScXMLPanTarget_UPDATE, METH_NOARGS, "SoScXMLPanTarget_UPDATE() -> SbName"},
	 { "SoScXMLPanTarget_END", _wrap_SoScXMLPanTarget_END, METH_NOARGS, "SoScXMLPanTarget_END() -> SbName"},
	 { "SoScXMLPanTarget_SET_FOCAL_POINT", _wrap_SoScXMLPanTarget_SET_FOCAL_POINT, METH_NOARGS, "SoScXMLPanTarget_SET_FOCAL_POINT() -> SbName"},
	 { "SoScXMLPanTarget_MOVE", _wrap_SoScXMLPanTarget_MOVE, METH_NOARGS, "SoScXMLPanTarget_MOVE() -> SbName"},
	 { "SoScXMLPanTarget_panCamera", _wrap_SoScXMLPanTarget_panCamera, METH_VARARGS, "SoScXMLPanTarget_panCamera(SoCamera camera, float vpaspect, SbPlane panplane, SbVec2f previous, SbVec2f current)"},
	 { "SoScXMLPanTarget_panSetFocalPoint", _wrap_SoScXMLPanTarget_panSetFocalPoint, METH_VARARGS, "SoScXMLPanTarget_panSetFocalPoint(SoCamera camera, SbVec3f worldspace)"},
	 { "SoScXMLPanTarget_translateCamera", _wrap_SoScXMLPanTarget_translateCamera, METH_VARARGS, "SoScXMLPanTarget_translateCamera(SoCamera camera, SbVec3f translation, SbBool cameraspace=0)"},
	 { "SoScXMLPanTarget_swigregister", SoScXMLPanTarget_swigregister, METH_O, NULL},
	 { "SoScXMLRotateTarget_getClassTypeId", _wrap_SoScXMLRotateTarget_getClassTypeId, METH_NOARGS, "SoScXMLRotateTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLRotateTarget_getTypeId", _wrap_SoScXMLRotateTarget_getTypeId, METH_O, "SoScXMLRotateTarget_getTypeId(SoScXMLRotateTarget self) -> SoType"},
	 { "SoScXMLRotateTarget_createInstance", _wrap_SoScXMLRotateTarget_createInstance, METH_NOARGS, "SoScXMLRotateTarget_createInstance() -> void *"},
	 { "SoScXMLRotateTarget_initClass", _wrap_SoScXMLRotateTarget_initClass, METH_NOARGS, "SoScXMLRotateTarget_initClass()"},
	 { "SoScXMLRotateTarget_cleanClass", _wrap_SoScXMLRotateTarget_cleanClass, METH_NOARGS, "SoScXMLRotateTarget_cleanClass()"},
	 { "SoScXMLRotateTarget_constructSingleton", _wrap_SoScXMLRotateTarget_constructSingleton, METH_NOARGS, "SoScXMLRotateTarget_constructSingleton() -> SoScXMLRotateTarget"},
	 { "SoScXMLRotateTarget_destructSingleton", _wrap_SoScXMLRotateTarget_destructSingleton, METH_NOARGS, "SoScXMLRotateTarget_destructSingleton()"},
	 { "SoScXMLRotateTarget_singleton", _wrap_SoScXMLRotateTarget_singleton, METH_NOARGS, "SoScXMLRotateTarget_singleton() -> SoScXMLRotateTarget"},
	 { "SoScXMLRotateTarget_BEGIN", _wrap_SoScXMLRotateTarget_BEGIN, METH_NOARGS, "SoScXMLRotateTarget_BEGIN() -> SbName"},
	 { "SoScXMLRotateTarget_UPDATE", _wrap_SoScXMLRotateTarget_UPDATE, METH_NOARGS, "SoScXMLRotateTarget_UPDATE() -> SbName"},
	 { "SoScXMLRotateTarget_END", _wrap_SoScXMLRotateTarget_END, METH_NOARGS, "SoScXMLRotateTarget_END() -> SbName"},
	 { "SoScXMLRotateTarget_SET_FOCAL_POINT", _wrap_SoScXMLRotateTarget_SET_FOCAL_POINT, METH_NOARGS, "SoScXMLRotateTarget_SET_FOCAL_POINT() -> SbName"},
	 { "SoScXMLRotateTarget_setFocalPoint", _wrap_SoScXMLRotateTarget_setFocalPoint, METH_VARARGS, "\n"
		"SoScXMLRotateTarget_setFocalPoint(SoCamera camera, SbVec3f worldspace)\n"
		"SoScXMLRotateTarget_setFocalPoint(SoCamera camera, SbVec3f worldspace, SbVec3f upvector)\n"
		""},
	 { "SoScXMLRotateTarget_reorientCamera", _wrap_SoScXMLRotateTarget_reorientCamera, METH_VARARGS, "SoScXMLRotateTarget_reorientCamera(SoCamera camera, SbRotation rot)"},
	 { "SoScXMLRotateTarget_swigregister", SoScXMLRotateTarget_swigregister, METH_O, NULL},
	 { "SoScXMLSeekTarget_getClassTypeId", _wrap_SoScXMLSeekTarget_getClassTypeId, METH_NOARGS, "SoScXMLSeekTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLSeekTarget_getTypeId", _wrap_SoScXMLSeekTarget_getTypeId, METH_O, "SoScXMLSeekTarget_getTypeId(SoScXMLSeekTarget self) -> SoType"},
	 { "SoScXMLSeekTarget_createInstance", _wrap_SoScXMLSeekTarget_createInstance, METH_NOARGS, "SoScXMLSeekTarget_createInstance() -> void *"},
	 { "SoScXMLSeekTarget_initClass", _wrap_SoScXMLSeekTarget_initClass, METH_NOARGS, "SoScXMLSeekTarget_initClass()"},
	 { "SoScXMLSeekTarget_cleanClass", _wrap_SoScXMLSeekTarget_cleanClass, METH_NOARGS, "SoScXMLSeekTarget_cleanClass()"},
	 { "SoScXMLSeekTarget_constructSingleton", _wrap_SoScXMLSeekTarget_constructSingleton, METH_NOARGS, "SoScXMLSeekTarget_constructSingleton() -> SoScXMLSeekTarget"},
	 { "SoScXMLSeekTarget_destructSingleton", _wrap_SoScXMLSeekTarget_destructSingleton, METH_NOARGS, "SoScXMLSeekTarget_destructSingleton()"},
	 { "SoScXMLSeekTarget_singleton", _wrap_SoScXMLSeekTarget_singleton, METH_NOARGS, "SoScXMLSeekTarget_singleton() -> SoScXMLSeekTarget"},
	 { "SoScXMLSeekTarget_BEGIN", _wrap_SoScXMLSeekTarget_BEGIN, METH_NOARGS, "SoScXMLSeekTarget_BEGIN() -> SbName"},
	 { "SoScXMLSeekTarget_UPDATE", _wrap_SoScXMLSeekTarget_UPDATE, METH_NOARGS, "SoScXMLSeekTarget_UPDATE() -> SbName"},
	 { "SoScXMLSeekTarget_END", _wrap_SoScXMLSeekTarget_END, METH_NOARGS, "SoScXMLSeekTarget_END() -> SbName"},
	 { "SoScXMLSeekTarget_swigregister", SoScXMLSeekTarget_swigregister, METH_O, NULL},
	 { "SoScXMLSpinTarget_getClassTypeId", _wrap_SoScXMLSpinTarget_getClassTypeId, METH_NOARGS, "SoScXMLSpinTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLSpinTarget_getTypeId", _wrap_SoScXMLSpinTarget_getTypeId, METH_O, "SoScXMLSpinTarget_getTypeId(SoScXMLSpinTarget self) -> SoType"},
	 { "SoScXMLSpinTarget_createInstance", _wrap_SoScXMLSpinTarget_createInstance, METH_NOARGS, "SoScXMLSpinTarget_createInstance() -> void *"},
	 { "SoScXMLSpinTarget_initClass", _wrap_SoScXMLSpinTarget_initClass, METH_NOARGS, "SoScXMLSpinTarget_initClass()"},
	 { "SoScXMLSpinTarget_cleanClass", _wrap_SoScXMLSpinTarget_cleanClass, METH_NOARGS, "SoScXMLSpinTarget_cleanClass()"},
	 { "SoScXMLSpinTarget_constructSingleton", _wrap_SoScXMLSpinTarget_constructSingleton, METH_NOARGS, "SoScXMLSpinTarget_constructSingleton() -> SoScXMLSpinTarget"},
	 { "SoScXMLSpinTarget_destructSingleton", _wrap_SoScXMLSpinTarget_destructSingleton, METH_NOARGS, "SoScXMLSpinTarget_destructSingleton()"},
	 { "SoScXMLSpinTarget_singleton", _wrap_SoScXMLSpinTarget_singleton, METH_NOARGS, "SoScXMLSpinTarget_singleton() -> SoScXMLSpinTarget"},
	 { "SoScXMLSpinTarget_BEGIN", _wrap_SoScXMLSpinTarget_BEGIN, METH_NOARGS, "SoScXMLSpinTarget_BEGIN() -> SbName"},
	 { "SoScXMLSpinTarget_UPDATE", _wrap_SoScXMLSpinTarget_UPDATE, METH_NOARGS, "SoScXMLSpinTarget_UPDATE() -> SbName"},
	 { "SoScXMLSpinTarget_END", _wrap_SoScXMLSpinTarget_END, METH_NOARGS, "SoScXMLSpinTarget_END() -> SbName"},
	 { "SoScXMLSpinTarget_reorientCamera", _wrap_SoScXMLSpinTarget_reorientCamera, METH_VARARGS, "SoScXMLSpinTarget_reorientCamera(SoCamera camera, SbRotation rot)"},
	 { "SoScXMLSpinTarget_swigregister", SoScXMLSpinTarget_swigregister, METH_O, NULL},
	 { "SoScXMLZoomTarget_getClassTypeId", _wrap_SoScXMLZoomTarget_getClassTypeId, METH_NOARGS, "SoScXMLZoomTarget_getClassTypeId() -> SoType"},
	 { "SoScXMLZoomTarget_getTypeId", _wrap_SoScXMLZoomTarget_getTypeId, METH_O, "SoScXMLZoomTarget_getTypeId(SoScXMLZoomTarget self) -> SoType"},
	 { "SoScXMLZoomTarget_createInstance", _wrap_SoScXMLZoomTarget_createInstance, METH_NOARGS, "SoScXMLZoomTarget_createInstance() -> void *"},
	 { "SoScXMLZoomTarget_initClass", _wrap_SoScXMLZoomTarget_initClass, METH_NOARGS, "SoScXMLZoomTarget_initClass()"},
	 { "SoScXMLZoomTarget_cleanClass", _wrap_SoScXMLZoomTarget_cleanClass, METH_NOARGS, "SoScXMLZoomTarget_cleanClass()"},
	 { "SoScXMLZoomTarget_constructSingleton", _wrap_SoScXMLZoomTarget_constructSingleton, METH_NOARGS, "SoScXMLZoomTarget_constructSingleton() -> SoScXMLZoomTarget"},
	 { "SoScXMLZoomTarget_destructSingleton", _wrap_SoScXMLZoomTarget_destructSingleton, METH_NOARGS, "SoScXMLZoomTarget_destructSingleton()"},
	 { "SoScXMLZoomTarget_singleton", _wrap_SoScXMLZoomTarget_singleton, METH_NOARGS, "SoScXMLZoomTarget_singleton() -> SoScXMLZoomTarget"},
	 { "SoScXMLZoomTarget_BEGIN", _wrap_SoScXMLZoomTarget_BEGIN, METH_NOARGS, "SoScXMLZoomTarget_BEGIN() -> SbName"},
	 { "SoScXMLZoomTarget_UPDATE", _wrap_SoScXMLZoomTarget_UPDATE, METH_NOARGS, "SoScXMLZoomTarget_UPDATE() -> SbName"},
	 { "SoScXMLZoomTarget_END", _wrap_SoScXMLZoomTarget_END, METH_NOARGS, "SoScXMLZoomTarget_END() -> SbName"},
	 { "SoScXMLZoomTarget_ZOOM", _wrap_SoScXMLZoomTarget_ZOOM, METH_NOARGS, "SoScXMLZoomTarget_ZOOM() -> SbName"},
	 { "SoScXMLZoomTarget_ZOOM_IN", _wrap_SoScXMLZoomTarget_ZOOM_IN, METH_NOARGS, "SoScXMLZoomTarget_ZOOM_IN() -> SbName"},
	 { "SoScXMLZoomTarget_ZOOM_OUT", _wrap_SoScXMLZoomTarget_ZOOM_OUT, METH_NOARGS, "SoScXMLZoomTarget_ZOOM_OUT() -> SbName"},
	 { "SoScXMLZoomTarget_RESET", _wrap_SoScXMLZoomTarget_RESET, METH_NOARGS, "SoScXMLZoomTarget_RESET() -> SbName"},
	 { "SoScXMLZoomTarget_zoom", _wrap_SoScXMLZoomTarget_zoom, METH_VARARGS, "SoScXMLZoomTarget_zoom(SoCamera camera, float factor)"},
	 { "SoScXMLZoomTarget_reset", _wrap_SoScXMLZoomTarget_reset, METH_O, "SoScXMLZoomTarget_reset(SoCamera camera)"},
	 { "SoScXMLZoomTarget_swigregister", SoScXMLZoomTarget_swigregister, METH_O, NULL},
	 { "ScXML_initClasses", _wrap_ScXML_initClasses, METH_NOARGS, "ScXML_initClasses()"},
	 { "ScXML_cleanClasses", _wrap_ScXML_cleanClasses, METH_NOARGS, "ScXML_cleanClasses()"},
	 { "ScXML_readFile", _wrap_ScXML_readFile, METH_O, "ScXML_readFile(char const * filename) -> ScXMLStateMachine"},
	 { "ScXML_readBuffer", _wrap_ScXML_readBuffer, METH_O, "ScXML_readBuffer(SbByteBuffer buffer) -> ScXMLStateMachine"},
	 { "ScXML_registerEvaluatorType", _wrap_ScXML_registerEvaluatorType, METH_VARARGS, "ScXML_registerEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"},
	 { "ScXML_unregisterEvaluatorType", _wrap_ScXML_unregisterEvaluatorType, METH_VARARGS, "ScXML_unregisterEvaluatorType(SbName profilename, SoType evaluatortype) -> SbBool"},
	 { "ScXML_getEvaluatorTypeForProfile", _wrap_ScXML_getEvaluatorTypeForProfile, METH_O, "ScXML_getEvaluatorTypeForProfile(SbName profilename) -> SoType"},
	 { "new_ScXML", _wrap_new_ScXML, METH_NOARGS, "new_ScXML() -> ScXML"},
	 { "delete_ScXML", _wrap_delete_ScXML, METH_O, "delete_ScXML(ScXML self)"},
	 { "ScXML_swigregister", ScXML_swigregister, METH_O, NULL},
	 { "ScXML_swiginit", ScXML_swiginit, METH_VARARGS, NULL},
	 { "ScXMLElt_getClassTypeId", _wrap_ScXMLElt_getClassTypeId, METH_NOARGS, "ScXMLElt_getClassTypeId() -> SoType"},
	 { "ScXMLElt_getTypeId", _wrap_ScXMLElt_getTypeId, METH_O, "ScXMLElt_getTypeId(ScXMLElt self) -> SoType"},
	 { "ScXMLElt_initClass", _wrap_ScXMLElt_initClass, METH_NOARGS, "ScXMLElt_initClass()"},
	 { "ScXMLElt_cleanClass", _wrap_ScXMLElt_cleanClass, METH_NOARGS, "ScXMLElt_cleanClass()"},
	 { "delete_ScXMLElt", _wrap_delete_ScXMLElt, METH_O, "delete_ScXMLElt(ScXMLElt self)"},
	 { "ScXMLElt_setXMLAttribute", _wrap_ScXMLElt_setXMLAttribute, METH_VARARGS, "ScXMLElt_setXMLAttribute(ScXMLElt self, char const * attribute, char const * value)"},
	 { "ScXMLElt_getXMLAttribute", _wrap_ScXMLElt_getXMLAttribute, METH_VARARGS, "ScXMLElt_getXMLAttribute(ScXMLElt self, char const * attribute) -> char const *"},
	 { "ScXMLElt_handleXMLAttributes", _wrap_ScXMLElt_handleXMLAttributes, METH_O, "ScXMLElt_handleXMLAttributes(ScXMLElt self) -> SbBool"},
	 { "ScXMLElt_search", _wrap_ScXMLElt_search, METH_VARARGS, "ScXMLElt_search(ScXMLElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLElt_clone", _wrap_ScXMLElt_clone, METH_O, "ScXMLElt_clone(ScXMLElt self) -> ScXMLElt"},
	 { "ScXMLElt_copyContents", _wrap_ScXMLElt_copyContents, METH_VARARGS, "ScXMLElt_copyContents(ScXMLElt self, ScXMLElt rhs)"},
	 { "ScXMLElt_setContainer", _wrap_ScXMLElt_setContainer, METH_VARARGS, "ScXMLElt_setContainer(ScXMLElt self, ScXMLElt container)"},
	 { "ScXMLElt_getContainer", _wrap_ScXMLElt_getContainer, METH_O, "ScXMLElt_getContainer(ScXMLElt self) -> ScXMLElt"},
	 { "ScXMLElt_isContainedIn", _wrap_ScXMLElt_isContainedIn, METH_VARARGS, "ScXMLElt_isContainedIn(ScXMLElt self, ScXMLElt object) -> SbBool"},
	 { "ScXMLElt_swigregister", ScXMLElt_swigregister, METH_O, NULL},
	 { "delete_ScXMLEltReader", _wrap_delete_ScXMLEltReader, METH_O, "delete_ScXMLEltReader(ScXMLEltReader self)"},
	 { "ScXMLEltReader_read", _wrap_ScXMLEltReader_read, METH_VARARGS, "ScXMLEltReader_read(ScXMLEltReader self, ScXMLElt container, cc_xml_elt * elt, ScXMLDocument doc, ScXMLStateMachine sm) -> ScXMLElt"},
	 { "ScXMLEltReader_swigregister", ScXMLEltReader_swigregister, METH_O, NULL},
	 { "ScXMLAbstractStateElt_getClassTypeId", _wrap_ScXMLAbstractStateElt_getClassTypeId, METH_NOARGS, "ScXMLAbstractStateElt_getClassTypeId() -> SoType"},
	 { "ScXMLAbstractStateElt_getTypeId", _wrap_ScXMLAbstractStateElt_getTypeId, METH_O, "ScXMLAbstractStateElt_getTypeId(ScXMLAbstractStateElt self) -> SoType"},
	 { "ScXMLAbstractStateElt_initClass", _wrap_ScXMLAbstractStateElt_initClass, METH_NOARGS, "ScXMLAbstractStateElt_initClass()"},
	 { "ScXMLAbstractStateElt_cleanClass", _wrap_ScXMLAbstractStateElt_cleanClass, METH_NOARGS, "ScXMLAbstractStateElt_cleanClass()"},
	 { "delete_ScXMLAbstractStateElt", _wrap_delete_ScXMLAbstractStateElt, METH_O, "delete_ScXMLAbstractStateElt(ScXMLAbstractStateElt self)"},
	 { "ScXMLAbstractStateElt_setIdAttribute", _wrap_ScXMLAbstractStateElt_setIdAttribute, METH_VARARGS, "ScXMLAbstractStateElt_setIdAttribute(ScXMLAbstractStateElt self, char const * id)"},
	 { "ScXMLAbstractStateElt_getIdAttribute", _wrap_ScXMLAbstractStateElt_getIdAttribute, METH_O, "ScXMLAbstractStateElt_getIdAttribute(ScXMLAbstractStateElt self) -> char const *"},
	 { "ScXMLAbstractStateElt_handleXMLAttributes", _wrap_ScXMLAbstractStateElt_handleXMLAttributes, METH_O, "ScXMLAbstractStateElt_handleXMLAttributes(ScXMLAbstractStateElt self) -> SbBool"},
	 { "ScXMLAbstractStateElt_copyContents", _wrap_ScXMLAbstractStateElt_copyContents, METH_VARARGS, "ScXMLAbstractStateElt_copyContents(ScXMLAbstractStateElt self, ScXMLElt rhs)"},
	 { "ScXMLAbstractStateElt_search", _wrap_ScXMLAbstractStateElt_search, METH_VARARGS, "ScXMLAbstractStateElt_search(ScXMLAbstractStateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLAbstractStateElt_swigregister", ScXMLAbstractStateElt_swigregister, METH_O, NULL},
	 { "ScXMLAnchorElt_getElementReader", _wrap_ScXMLAnchorElt_getElementReader, METH_NOARGS, "ScXMLAnchorElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLAnchorElt_getClassTypeId", _wrap_ScXMLAnchorElt_getClassTypeId, METH_NOARGS, "ScXMLAnchorElt_getClassTypeId() -> SoType"},
	 { "ScXMLAnchorElt_getTypeId", _wrap_ScXMLAnchorElt_getTypeId, METH_O, "ScXMLAnchorElt_getTypeId(ScXMLAnchorElt self) -> SoType"},
	 { "ScXMLAnchorElt_createInstance", _wrap_ScXMLAnchorElt_createInstance, METH_NOARGS, "ScXMLAnchorElt_createInstance() -> void *"},
	 { "ScXMLAnchorElt_initClass", _wrap_ScXMLAnchorElt_initClass, METH_NOARGS, "ScXMLAnchorElt_initClass()"},
	 { "ScXMLAnchorElt_cleanClass", _wrap_ScXMLAnchorElt_cleanClass, METH_NOARGS, "ScXMLAnchorElt_cleanClass()"},
	 { "new_ScXMLAnchorElt", _wrap_new_ScXMLAnchorElt, METH_NOARGS, "new_ScXMLAnchorElt() -> ScXMLAnchorElt"},
	 { "delete_ScXMLAnchorElt", _wrap_delete_ScXMLAnchorElt, METH_O, "delete_ScXMLAnchorElt(ScXMLAnchorElt self)"},
	 { "ScXMLAnchorElt_setTypeAttribute", _wrap_ScXMLAnchorElt_setTypeAttribute, METH_VARARGS, "ScXMLAnchorElt_setTypeAttribute(ScXMLAnchorElt self, char const * type)"},
	 { "ScXMLAnchorElt_getTypeAttribute", _wrap_ScXMLAnchorElt_getTypeAttribute, METH_O, "ScXMLAnchorElt_getTypeAttribute(ScXMLAnchorElt self) -> char const *"},
	 { "ScXMLAnchorElt_setSnapshotAttribute", _wrap_ScXMLAnchorElt_setSnapshotAttribute, METH_VARARGS, "ScXMLAnchorElt_setSnapshotAttribute(ScXMLAnchorElt self, char const * snapshot)"},
	 { "ScXMLAnchorElt_getSnapshotAttribute", _wrap_ScXMLAnchorElt_getSnapshotAttribute, METH_O, "ScXMLAnchorElt_getSnapshotAttribute(ScXMLAnchorElt self) -> char const *"},
	 { "ScXMLAnchorElt_handleXMLAttributes", _wrap_ScXMLAnchorElt_handleXMLAttributes, METH_O, "ScXMLAnchorElt_handleXMLAttributes(ScXMLAnchorElt self) -> SbBool"},
	 { "ScXMLAnchorElt_copyContents", _wrap_ScXMLAnchorElt_copyContents, METH_VARARGS, "ScXMLAnchorElt_copyContents(ScXMLAnchorElt self, ScXMLElt rhs)"},
	 { "ScXMLAnchorElt_search", _wrap_ScXMLAnchorElt_search, METH_VARARGS, "ScXMLAnchorElt_search(ScXMLAnchorElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLAnchorElt_swigregister", ScXMLAnchorElt_swigregister, METH_O, NULL},
	 { "ScXMLAnchorElt_swiginit", ScXMLAnchorElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLExecutableElt_getClassTypeId", _wrap_ScXMLExecutableElt_getClassTypeId, METH_NOARGS, "ScXMLExecutableElt_getClassTypeId() -> SoType"},
	 { "ScXMLExecutableElt_getTypeId", _wrap_ScXMLExecutableElt_getTypeId, METH_O, "ScXMLExecutableElt_getTypeId(ScXMLExecutableElt self) -> SoType"},
	 { "ScXMLExecutableElt_initClass", _wrap_ScXMLExecutableElt_initClass, METH_NOARGS, "ScXMLExecutableElt_initClass()"},
	 { "ScXMLExecutableElt_cleanClass", _wrap_ScXMLExecutableElt_cleanClass, METH_NOARGS, "ScXMLExecutableElt_cleanClass()"},
	 { "delete_ScXMLExecutableElt", _wrap_delete_ScXMLExecutableElt, METH_O, "delete_ScXMLExecutableElt(ScXMLExecutableElt self)"},
	 { "ScXMLExecutableElt_copyContents", _wrap_ScXMLExecutableElt_copyContents, METH_VARARGS, "ScXMLExecutableElt_copyContents(ScXMLExecutableElt self, ScXMLElt rhs)"},
	 { "ScXMLExecutableElt_execute", _wrap_ScXMLExecutableElt_execute, METH_VARARGS, "ScXMLExecutableElt_execute(ScXMLExecutableElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLExecutableElt_swigregister", ScXMLExecutableElt_swigregister, METH_O, NULL},
	 { "ScXMLAssignElt_getElementReader", _wrap_ScXMLAssignElt_getElementReader, METH_NOARGS, "ScXMLAssignElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLAssignElt_getClassTypeId", _wrap_ScXMLAssignElt_getClassTypeId, METH_NOARGS, "ScXMLAssignElt_getClassTypeId() -> SoType"},
	 { "ScXMLAssignElt_getTypeId", _wrap_ScXMLAssignElt_getTypeId, METH_O, "ScXMLAssignElt_getTypeId(ScXMLAssignElt self) -> SoType"},
	 { "ScXMLAssignElt_createInstance", _wrap_ScXMLAssignElt_createInstance, METH_NOARGS, "ScXMLAssignElt_createInstance() -> void *"},
	 { "ScXMLAssignElt_initClass", _wrap_ScXMLAssignElt_initClass, METH_NOARGS, "ScXMLAssignElt_initClass()"},
	 { "ScXMLAssignElt_cleanClass", _wrap_ScXMLAssignElt_cleanClass, METH_NOARGS, "ScXMLAssignElt_cleanClass()"},
	 { "new_ScXMLAssignElt", _wrap_new_ScXMLAssignElt, METH_NOARGS, "new_ScXMLAssignElt() -> ScXMLAssignElt"},
	 { "delete_ScXMLAssignElt", _wrap_delete_ScXMLAssignElt, METH_O, "delete_ScXMLAssignElt(ScXMLAssignElt self)"},
	 { "ScXMLAssignElt_setLocationAttribute", _wrap_ScXMLAssignElt_setLocationAttribute, METH_VARARGS, "ScXMLAssignElt_setLocationAttribute(ScXMLAssignElt self, char const * location)"},
	 { "ScXMLAssignElt_getLocationAttribute", _wrap_ScXMLAssignElt_getLocationAttribute, METH_O, "ScXMLAssignElt_getLocationAttribute(ScXMLAssignElt self) -> char const *"},
	 { "ScXMLAssignElt_setDataIDAttribute", _wrap_ScXMLAssignElt_setDataIDAttribute, METH_VARARGS, "ScXMLAssignElt_setDataIDAttribute(ScXMLAssignElt self, char const * dataID)"},
	 { "ScXMLAssignElt_getDataIDAttribute", _wrap_ScXMLAssignElt_getDataIDAttribute, METH_O, "ScXMLAssignElt_getDataIDAttribute(ScXMLAssignElt self) -> char const *"},
	 { "ScXMLAssignElt_setExprAttribute", _wrap_ScXMLAssignElt_setExprAttribute, METH_VARARGS, "ScXMLAssignElt_setExprAttribute(ScXMLAssignElt self, char const * expr)"},
	 { "ScXMLAssignElt_getExprAttribute", _wrap_ScXMLAssignElt_getExprAttribute, METH_O, "ScXMLAssignElt_getExprAttribute(ScXMLAssignElt self) -> char const *"},
	 { "ScXMLAssignElt_handleXMLAttributes", _wrap_ScXMLAssignElt_handleXMLAttributes, METH_O, "ScXMLAssignElt_handleXMLAttributes(ScXMLAssignElt self) -> SbBool"},
	 { "ScXMLAssignElt_copyContents", _wrap_ScXMLAssignElt_copyContents, METH_VARARGS, "ScXMLAssignElt_copyContents(ScXMLAssignElt self, ScXMLElt rhs)"},
	 { "ScXMLAssignElt_search", _wrap_ScXMLAssignElt_search, METH_VARARGS, "ScXMLAssignElt_search(ScXMLAssignElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLAssignElt_execute", _wrap_ScXMLAssignElt_execute, METH_VARARGS, "ScXMLAssignElt_execute(ScXMLAssignElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLAssignElt_swigregister", ScXMLAssignElt_swigregister, METH_O, NULL},
	 { "ScXMLAssignElt_swiginit", ScXMLAssignElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLEvaluator_getClassTypeId", _wrap_ScXMLEvaluator_getClassTypeId, METH_NOARGS, "ScXMLEvaluator_getClassTypeId() -> SoType"},
	 { "ScXMLEvaluator_getTypeId", _wrap_ScXMLEvaluator_getTypeId, METH_O, "ScXMLEvaluator_getTypeId(ScXMLEvaluator self) -> SoType"},
	 { "ScXMLEvaluator_initClass", _wrap_ScXMLEvaluator_initClass, METH_NOARGS, "ScXMLEvaluator_initClass()"},
	 { "ScXMLEvaluator_cleanClass", _wrap_ScXMLEvaluator_cleanClass, METH_NOARGS, "ScXMLEvaluator_cleanClass()"},
	 { "delete_ScXMLEvaluator", _wrap_delete_ScXMLEvaluator, METH_O, "delete_ScXMLEvaluator(ScXMLEvaluator self)"},
	 { "ScXMLEvaluator_setStateMachine", _wrap_ScXMLEvaluator_setStateMachine, METH_VARARGS, "ScXMLEvaluator_setStateMachine(ScXMLEvaluator self, ScXMLStateMachine sm)"},
	 { "ScXMLEvaluator_getStateMachine", _wrap_ScXMLEvaluator_getStateMachine, METH_O, "ScXMLEvaluator_getStateMachine(ScXMLEvaluator self) -> ScXMLStateMachine"},
	 { "ScXMLEvaluator_evaluate", _wrap_ScXMLEvaluator_evaluate, METH_VARARGS, "ScXMLEvaluator_evaluate(ScXMLEvaluator self, char const * expression) -> ScXMLDataObj"},
	 { "ScXMLEvaluator_setAtLocation", _wrap_ScXMLEvaluator_setAtLocation, METH_VARARGS, "ScXMLEvaluator_setAtLocation(ScXMLEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"},
	 { "ScXMLEvaluator_locate", _wrap_ScXMLEvaluator_locate, METH_VARARGS, "ScXMLEvaluator_locate(ScXMLEvaluator self, char const * location) -> ScXMLDataObj"},
	 { "ScXMLEvaluator_clearTemporaryVariables", _wrap_ScXMLEvaluator_clearTemporaryVariables, METH_O, "ScXMLEvaluator_clearTemporaryVariables(ScXMLEvaluator self)"},
	 { "ScXMLEvaluator_swigregister", ScXMLEvaluator_swigregister, METH_O, NULL},
	 { "ScXMLDataObj_getClassTypeId", _wrap_ScXMLDataObj_getClassTypeId, METH_NOARGS, "ScXMLDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLDataObj_getTypeId", _wrap_ScXMLDataObj_getTypeId, METH_O, "ScXMLDataObj_getTypeId(ScXMLDataObj self) -> SoType"},
	 { "ScXMLDataObj_initClass", _wrap_ScXMLDataObj_initClass, METH_NOARGS, "ScXMLDataObj_initClass()"},
	 { "ScXMLDataObj_cleanClass", _wrap_ScXMLDataObj_cleanClass, METH_NOARGS, "ScXMLDataObj_cleanClass()"},
	 { "delete_ScXMLDataObj", _wrap_delete_ScXMLDataObj, METH_O, "delete_ScXMLDataObj(ScXMLDataObj self)"},
	 { "ScXMLDataObj_setContainer", _wrap_ScXMLDataObj_setContainer, METH_VARARGS, "ScXMLDataObj_setContainer(ScXMLDataObj self, ScXMLObject container)"},
	 { "ScXMLDataObj_getContainer", _wrap_ScXMLDataObj_getContainer, METH_O, "ScXMLDataObj_getContainer(ScXMLDataObj self) -> ScXMLObject"},
	 { "ScXMLDataObj_swigregister", ScXMLDataObj_swigregister, METH_O, NULL},
	 { "ScXMLConstantDataObj_getClassTypeId", _wrap_ScXMLConstantDataObj_getClassTypeId, METH_NOARGS, "ScXMLConstantDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLConstantDataObj_getTypeId", _wrap_ScXMLConstantDataObj_getTypeId, METH_O, "ScXMLConstantDataObj_getTypeId(ScXMLConstantDataObj self) -> SoType"},
	 { "ScXMLConstantDataObj_initClass", _wrap_ScXMLConstantDataObj_initClass, METH_NOARGS, "ScXMLConstantDataObj_initClass()"},
	 { "ScXMLConstantDataObj_cleanClass", _wrap_ScXMLConstantDataObj_cleanClass, METH_NOARGS, "ScXMLConstantDataObj_cleanClass()"},
	 { "ScXMLConstantDataObj_clone", _wrap_ScXMLConstantDataObj_clone, METH_O, "ScXMLConstantDataObj_clone(ScXMLConstantDataObj self) -> ScXMLDataObj"},
	 { "ScXMLConstantDataObj_convertToString", _wrap_ScXMLConstantDataObj_convertToString, METH_VARARGS, "ScXMLConstantDataObj_convertToString(ScXMLConstantDataObj self, SbString str)"},
	 { "delete_ScXMLConstantDataObj", _wrap_delete_ScXMLConstantDataObj, METH_O, "delete_ScXMLConstantDataObj(ScXMLConstantDataObj self)"},
	 { "ScXMLConstantDataObj_swigregister", ScXMLConstantDataObj_swigregister, METH_O, NULL},
	 { "ScXMLStringDataObj_getClassTypeId", _wrap_ScXMLStringDataObj_getClassTypeId, METH_NOARGS, "ScXMLStringDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLStringDataObj_getTypeId", _wrap_ScXMLStringDataObj_getTypeId, METH_O, "ScXMLStringDataObj_getTypeId(ScXMLStringDataObj self) -> SoType"},
	 { "ScXMLStringDataObj_createInstance", _wrap_ScXMLStringDataObj_createInstance, METH_NOARGS, "ScXMLStringDataObj_createInstance() -> void *"},
	 { "ScXMLStringDataObj_initClass", _wrap_ScXMLStringDataObj_initClass, METH_NOARGS, "ScXMLStringDataObj_initClass()"},
	 { "ScXMLStringDataObj_cleanClass", _wrap_ScXMLStringDataObj_cleanClass, METH_NOARGS, "ScXMLStringDataObj_cleanClass()"},
	 { "ScXMLStringDataObj_createFor", _wrap_ScXMLStringDataObj_createFor, METH_O, "ScXMLStringDataObj_createFor(char const * value) -> ScXMLDataObj"},
	 { "new_ScXMLStringDataObj", _wrap_new_ScXMLStringDataObj, METH_VARARGS, "\n"
		"ScXMLStringDataObj()\n"
		"new_ScXMLStringDataObj(char const * value) -> ScXMLStringDataObj\n"
		""},
	 { "delete_ScXMLStringDataObj", _wrap_delete_ScXMLStringDataObj, METH_O, "delete_ScXMLStringDataObj(ScXMLStringDataObj self)"},
	 { "ScXMLStringDataObj_setString", _wrap_ScXMLStringDataObj_setString, METH_VARARGS, "ScXMLStringDataObj_setString(ScXMLStringDataObj self, char const * value)"},
	 { "ScXMLStringDataObj_getString", _wrap_ScXMLStringDataObj_getString, METH_O, "ScXMLStringDataObj_getString(ScXMLStringDataObj self) -> char const *"},
	 { "ScXMLStringDataObj_clone", _wrap_ScXMLStringDataObj_clone, METH_O, "ScXMLStringDataObj_clone(ScXMLStringDataObj self) -> ScXMLDataObj"},
	 { "ScXMLStringDataObj_convertToString", _wrap_ScXMLStringDataObj_convertToString, METH_VARARGS, "ScXMLStringDataObj_convertToString(ScXMLStringDataObj self, SbString str)"},
	 { "ScXMLStringDataObj_swigregister", ScXMLStringDataObj_swigregister, METH_O, NULL},
	 { "ScXMLStringDataObj_swiginit", ScXMLStringDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLRealDataObj_getClassTypeId", _wrap_ScXMLRealDataObj_getClassTypeId, METH_NOARGS, "ScXMLRealDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLRealDataObj_getTypeId", _wrap_ScXMLRealDataObj_getTypeId, METH_O, "ScXMLRealDataObj_getTypeId(ScXMLRealDataObj self) -> SoType"},
	 { "ScXMLRealDataObj_createInstance", _wrap_ScXMLRealDataObj_createInstance, METH_NOARGS, "ScXMLRealDataObj_createInstance() -> void *"},
	 { "ScXMLRealDataObj_initClass", _wrap_ScXMLRealDataObj_initClass, METH_NOARGS, "ScXMLRealDataObj_initClass()"},
	 { "ScXMLRealDataObj_cleanClass", _wrap_ScXMLRealDataObj_cleanClass, METH_NOARGS, "ScXMLRealDataObj_cleanClass()"},
	 { "ScXMLRealDataObj_createFor", _wrap_ScXMLRealDataObj_createFor, METH_O, "ScXMLRealDataObj_createFor(double value) -> ScXMLDataObj"},
	 { "new_ScXMLRealDataObj", _wrap_new_ScXMLRealDataObj, METH_VARARGS, "\n"
		"ScXMLRealDataObj()\n"
		"new_ScXMLRealDataObj(double value) -> ScXMLRealDataObj\n"
		""},
	 { "delete_ScXMLRealDataObj", _wrap_delete_ScXMLRealDataObj, METH_O, "delete_ScXMLRealDataObj(ScXMLRealDataObj self)"},
	 { "ScXMLRealDataObj_setReal", _wrap_ScXMLRealDataObj_setReal, METH_VARARGS, "ScXMLRealDataObj_setReal(ScXMLRealDataObj self, double value)"},
	 { "ScXMLRealDataObj_getReal", _wrap_ScXMLRealDataObj_getReal, METH_O, "ScXMLRealDataObj_getReal(ScXMLRealDataObj self) -> double"},
	 { "ScXMLRealDataObj_clone", _wrap_ScXMLRealDataObj_clone, METH_O, "ScXMLRealDataObj_clone(ScXMLRealDataObj self) -> ScXMLDataObj"},
	 { "ScXMLRealDataObj_convertToString", _wrap_ScXMLRealDataObj_convertToString, METH_VARARGS, "ScXMLRealDataObj_convertToString(ScXMLRealDataObj self, SbString str)"},
	 { "ScXMLRealDataObj_swigregister", ScXMLRealDataObj_swigregister, METH_O, NULL},
	 { "ScXMLRealDataObj_swiginit", ScXMLRealDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLBoolDataObj_getClassTypeId", _wrap_ScXMLBoolDataObj_getClassTypeId, METH_NOARGS, "ScXMLBoolDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLBoolDataObj_getTypeId", _wrap_ScXMLBoolDataObj_getTypeId, METH_O, "ScXMLBoolDataObj_getTypeId(ScXMLBoolDataObj self) -> SoType"},
	 { "ScXMLBoolDataObj_createInstance", _wrap_ScXMLBoolDataObj_createInstance, METH_NOARGS, "ScXMLBoolDataObj_createInstance() -> void *"},
	 { "ScXMLBoolDataObj_initClass", _wrap_ScXMLBoolDataObj_initClass, METH_NOARGS, "ScXMLBoolDataObj_initClass()"},
	 { "ScXMLBoolDataObj_cleanClass", _wrap_ScXMLBoolDataObj_cleanClass, METH_NOARGS, "ScXMLBoolDataObj_cleanClass()"},
	 { "ScXMLBoolDataObj_createFor", _wrap_ScXMLBoolDataObj_createFor, METH_O, "ScXMLBoolDataObj_createFor(SbBool value) -> ScXMLDataObj"},
	 { "new_ScXMLBoolDataObj", _wrap_new_ScXMLBoolDataObj, METH_VARARGS, "\n"
		"ScXMLBoolDataObj()\n"
		"new_ScXMLBoolDataObj(SbBool value) -> ScXMLBoolDataObj\n"
		""},
	 { "delete_ScXMLBoolDataObj", _wrap_delete_ScXMLBoolDataObj, METH_O, "delete_ScXMLBoolDataObj(ScXMLBoolDataObj self)"},
	 { "ScXMLBoolDataObj_setBool", _wrap_ScXMLBoolDataObj_setBool, METH_VARARGS, "ScXMLBoolDataObj_setBool(ScXMLBoolDataObj self, SbBool value)"},
	 { "ScXMLBoolDataObj_getBool", _wrap_ScXMLBoolDataObj_getBool, METH_O, "ScXMLBoolDataObj_getBool(ScXMLBoolDataObj self) -> SbBool"},
	 { "ScXMLBoolDataObj_clone", _wrap_ScXMLBoolDataObj_clone, METH_O, "ScXMLBoolDataObj_clone(ScXMLBoolDataObj self) -> ScXMLDataObj"},
	 { "ScXMLBoolDataObj_convertToString", _wrap_ScXMLBoolDataObj_convertToString, METH_VARARGS, "ScXMLBoolDataObj_convertToString(ScXMLBoolDataObj self, SbString str)"},
	 { "ScXMLBoolDataObj_swigregister", ScXMLBoolDataObj_swigregister, METH_O, NULL},
	 { "ScXMLBoolDataObj_swiginit", ScXMLBoolDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLSbDataObj_getClassTypeId", _wrap_ScXMLSbDataObj_getClassTypeId, METH_NOARGS, "ScXMLSbDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLSbDataObj_getTypeId", _wrap_ScXMLSbDataObj_getTypeId, METH_O, "ScXMLSbDataObj_getTypeId(ScXMLSbDataObj self) -> SoType"},
	 { "ScXMLSbDataObj_createInstance", _wrap_ScXMLSbDataObj_createInstance, METH_NOARGS, "ScXMLSbDataObj_createInstance() -> void *"},
	 { "ScXMLSbDataObj_initClass", _wrap_ScXMLSbDataObj_initClass, METH_NOARGS, "ScXMLSbDataObj_initClass()"},
	 { "ScXMLSbDataObj_cleanClass", _wrap_ScXMLSbDataObj_cleanClass, METH_NOARGS, "ScXMLSbDataObj_cleanClass()"},
	 { "ScXMLSbDataObj_createFor", _wrap_ScXMLSbDataObj_createFor, METH_O, "ScXMLSbDataObj_createFor(char const * value) -> ScXMLDataObj"},
	 { "new_ScXMLSbDataObj", _wrap_new_ScXMLSbDataObj, METH_VARARGS, "\n"
		"ScXMLSbDataObj()\n"
		"new_ScXMLSbDataObj(char const * value) -> ScXMLSbDataObj\n"
		""},
	 { "delete_ScXMLSbDataObj", _wrap_delete_ScXMLSbDataObj, METH_O, "delete_ScXMLSbDataObj(ScXMLSbDataObj self)"},
	 { "ScXMLSbDataObj_setSbValue", _wrap_ScXMLSbDataObj_setSbValue, METH_VARARGS, "ScXMLSbDataObj_setSbValue(ScXMLSbDataObj self, char const * value)"},
	 { "ScXMLSbDataObj_getSbValue", _wrap_ScXMLSbDataObj_getSbValue, METH_O, "ScXMLSbDataObj_getSbValue(ScXMLSbDataObj self) -> char const *"},
	 { "ScXMLSbDataObj_clone", _wrap_ScXMLSbDataObj_clone, METH_O, "ScXMLSbDataObj_clone(ScXMLSbDataObj self) -> ScXMLDataObj"},
	 { "ScXMLSbDataObj_convertToString", _wrap_ScXMLSbDataObj_convertToString, METH_VARARGS, "ScXMLSbDataObj_convertToString(ScXMLSbDataObj self, SbString str)"},
	 { "ScXMLSbDataObj_swigregister", ScXMLSbDataObj_swigregister, METH_O, NULL},
	 { "ScXMLSbDataObj_swiginit", ScXMLSbDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLXMLDataObj_getClassTypeId", _wrap_ScXMLXMLDataObj_getClassTypeId, METH_NOARGS, "ScXMLXMLDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLXMLDataObj_getTypeId", _wrap_ScXMLXMLDataObj_getTypeId, METH_O, "ScXMLXMLDataObj_getTypeId(ScXMLXMLDataObj self) -> SoType"},
	 { "ScXMLXMLDataObj_createInstance", _wrap_ScXMLXMLDataObj_createInstance, METH_NOARGS, "ScXMLXMLDataObj_createInstance() -> void *"},
	 { "ScXMLXMLDataObj_initClass", _wrap_ScXMLXMLDataObj_initClass, METH_NOARGS, "ScXMLXMLDataObj_initClass()"},
	 { "ScXMLXMLDataObj_cleanClass", _wrap_ScXMLXMLDataObj_cleanClass, METH_NOARGS, "ScXMLXMLDataObj_cleanClass()"},
	 { "new_ScXMLXMLDataObj", _wrap_new_ScXMLXMLDataObj, METH_NOARGS, "new_ScXMLXMLDataObj() -> ScXMLXMLDataObj"},
	 { "delete_ScXMLXMLDataObj", _wrap_delete_ScXMLXMLDataObj, METH_O, "delete_ScXMLXMLDataObj(ScXMLXMLDataObj self)"},
	 { "ScXMLXMLDataObj_clone", _wrap_ScXMLXMLDataObj_clone, METH_O, "ScXMLXMLDataObj_clone(ScXMLXMLDataObj self) -> ScXMLDataObj"},
	 { "ScXMLXMLDataObj_swigregister", ScXMLXMLDataObj_swigregister, METH_O, NULL},
	 { "ScXMLXMLDataObj_swiginit", ScXMLXMLDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLExprDataObj_getClassTypeId", _wrap_ScXMLExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLExprDataObj_getTypeId", _wrap_ScXMLExprDataObj_getTypeId, METH_O, "ScXMLExprDataObj_getTypeId(ScXMLExprDataObj self) -> SoType"},
	 { "ScXMLExprDataObj_initClass", _wrap_ScXMLExprDataObj_initClass, METH_NOARGS, "ScXMLExprDataObj_initClass()"},
	 { "ScXMLExprDataObj_cleanClass", _wrap_ScXMLExprDataObj_cleanClass, METH_NOARGS, "ScXMLExprDataObj_cleanClass()"},
	 { "delete_ScXMLExprDataObj", _wrap_delete_ScXMLExprDataObj, METH_O, "delete_ScXMLExprDataObj(ScXMLExprDataObj self)"},
	 { "ScXMLExprDataObj_evaluate", _wrap_ScXMLExprDataObj_evaluate, METH_VARARGS, "ScXMLExprDataObj_evaluate(ScXMLExprDataObj self, ScXMLStateMachine sm) -> ScXMLDataObj"},
	 { "ScXMLExprDataObj_swigregister", ScXMLExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLReferenceDataObj_getClassTypeId", _wrap_ScXMLReferenceDataObj_getClassTypeId, METH_NOARGS, "ScXMLReferenceDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLReferenceDataObj_getTypeId", _wrap_ScXMLReferenceDataObj_getTypeId, METH_O, "ScXMLReferenceDataObj_getTypeId(ScXMLReferenceDataObj self) -> SoType"},
	 { "ScXMLReferenceDataObj_createInstance", _wrap_ScXMLReferenceDataObj_createInstance, METH_NOARGS, "ScXMLReferenceDataObj_createInstance() -> void *"},
	 { "ScXMLReferenceDataObj_initClass", _wrap_ScXMLReferenceDataObj_initClass, METH_NOARGS, "ScXMLReferenceDataObj_initClass()"},
	 { "ScXMLReferenceDataObj_cleanClass", _wrap_ScXMLReferenceDataObj_cleanClass, METH_NOARGS, "ScXMLReferenceDataObj_cleanClass()"},
	 { "ScXMLReferenceDataObj_createFor", _wrap_ScXMLReferenceDataObj_createFor, METH_O, "ScXMLReferenceDataObj_createFor(char const * reference) -> ScXMLDataObj"},
	 { "new_ScXMLReferenceDataObj", _wrap_new_ScXMLReferenceDataObj, METH_VARARGS, "\n"
		"ScXMLReferenceDataObj()\n"
		"new_ScXMLReferenceDataObj(char const * reference) -> ScXMLReferenceDataObj\n"
		""},
	 { "delete_ScXMLReferenceDataObj", _wrap_delete_ScXMLReferenceDataObj, METH_O, "delete_ScXMLReferenceDataObj(ScXMLReferenceDataObj self)"},
	 { "ScXMLReferenceDataObj_setReference", _wrap_ScXMLReferenceDataObj_setReference, METH_VARARGS, "ScXMLReferenceDataObj_setReference(ScXMLReferenceDataObj self, char const * reference)"},
	 { "ScXMLReferenceDataObj_getReference", _wrap_ScXMLReferenceDataObj_getReference, METH_O, "ScXMLReferenceDataObj_getReference(ScXMLReferenceDataObj self) -> char const *"},
	 { "ScXMLReferenceDataObj_evaluateNow", _wrap_ScXMLReferenceDataObj_evaluateNow, METH_VARARGS, "ScXMLReferenceDataObj_evaluateNow(ScXMLReferenceDataObj self, ScXMLStateMachine sm, ScXMLDataObj *& pointer) -> SbBool"},
	 { "ScXMLReferenceDataObj_swigregister", ScXMLReferenceDataObj_swigregister, METH_O, NULL},
	 { "ScXMLReferenceDataObj_swiginit", ScXMLReferenceDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLAndOpExprDataObj_getClassTypeId", _wrap_ScXMLAndOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLAndOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLAndOpExprDataObj_getTypeId", _wrap_ScXMLAndOpExprDataObj_getTypeId, METH_O, "ScXMLAndOpExprDataObj_getTypeId(ScXMLAndOpExprDataObj self) -> SoType"},
	 { "ScXMLAndOpExprDataObj_createInstance", _wrap_ScXMLAndOpExprDataObj_createInstance, METH_NOARGS, "ScXMLAndOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLAndOpExprDataObj_initClass", _wrap_ScXMLAndOpExprDataObj_initClass, METH_NOARGS, "ScXMLAndOpExprDataObj_initClass()"},
	 { "ScXMLAndOpExprDataObj_cleanClass", _wrap_ScXMLAndOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLAndOpExprDataObj_cleanClass()"},
	 { "ScXMLAndOpExprDataObj_createFor", _wrap_ScXMLAndOpExprDataObj_createFor, METH_VARARGS, "ScXMLAndOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLAndOpExprDataObj", _wrap_new_ScXMLAndOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLAndOpExprDataObj()\n"
		"new_ScXMLAndOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAndOpExprDataObj\n"
		""},
	 { "delete_ScXMLAndOpExprDataObj", _wrap_delete_ScXMLAndOpExprDataObj, METH_O, "delete_ScXMLAndOpExprDataObj(ScXMLAndOpExprDataObj self)"},
	 { "ScXMLAndOpExprDataObj_setLHS", _wrap_ScXMLAndOpExprDataObj_setLHS, METH_VARARGS, "ScXMLAndOpExprDataObj_setLHS(ScXMLAndOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLAndOpExprDataObj_getLHS", _wrap_ScXMLAndOpExprDataObj_getLHS, METH_O, "ScXMLAndOpExprDataObj_getLHS(ScXMLAndOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAndOpExprDataObj_setRHS", _wrap_ScXMLAndOpExprDataObj_setRHS, METH_VARARGS, "ScXMLAndOpExprDataObj_setRHS(ScXMLAndOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLAndOpExprDataObj_getRHS", _wrap_ScXMLAndOpExprDataObj_getRHS, METH_O, "ScXMLAndOpExprDataObj_getRHS(ScXMLAndOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAndOpExprDataObj_swigregister", ScXMLAndOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLAndOpExprDataObj_swiginit", ScXMLAndOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLOrOpExprDataObj_getClassTypeId", _wrap_ScXMLOrOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLOrOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLOrOpExprDataObj_getTypeId", _wrap_ScXMLOrOpExprDataObj_getTypeId, METH_O, "ScXMLOrOpExprDataObj_getTypeId(ScXMLOrOpExprDataObj self) -> SoType"},
	 { "ScXMLOrOpExprDataObj_createInstance", _wrap_ScXMLOrOpExprDataObj_createInstance, METH_NOARGS, "ScXMLOrOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLOrOpExprDataObj_initClass", _wrap_ScXMLOrOpExprDataObj_initClass, METH_NOARGS, "ScXMLOrOpExprDataObj_initClass()"},
	 { "ScXMLOrOpExprDataObj_cleanClass", _wrap_ScXMLOrOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLOrOpExprDataObj_cleanClass()"},
	 { "ScXMLOrOpExprDataObj_createFor", _wrap_ScXMLOrOpExprDataObj_createFor, METH_VARARGS, "ScXMLOrOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLOrOpExprDataObj", _wrap_new_ScXMLOrOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLOrOpExprDataObj()\n"
		"new_ScXMLOrOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLOrOpExprDataObj\n"
		""},
	 { "delete_ScXMLOrOpExprDataObj", _wrap_delete_ScXMLOrOpExprDataObj, METH_O, "delete_ScXMLOrOpExprDataObj(ScXMLOrOpExprDataObj self)"},
	 { "ScXMLOrOpExprDataObj_setLHS", _wrap_ScXMLOrOpExprDataObj_setLHS, METH_VARARGS, "ScXMLOrOpExprDataObj_setLHS(ScXMLOrOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLOrOpExprDataObj_getLHS", _wrap_ScXMLOrOpExprDataObj_getLHS, METH_O, "ScXMLOrOpExprDataObj_getLHS(ScXMLOrOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLOrOpExprDataObj_setRHS", _wrap_ScXMLOrOpExprDataObj_setRHS, METH_VARARGS, "ScXMLOrOpExprDataObj_setRHS(ScXMLOrOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLOrOpExprDataObj_getRHS", _wrap_ScXMLOrOpExprDataObj_getRHS, METH_O, "ScXMLOrOpExprDataObj_getRHS(ScXMLOrOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLOrOpExprDataObj_swigregister", ScXMLOrOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLOrOpExprDataObj_swiginit", ScXMLOrOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLNotOpExprDataObj_getClassTypeId", _wrap_ScXMLNotOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLNotOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLNotOpExprDataObj_getTypeId", _wrap_ScXMLNotOpExprDataObj_getTypeId, METH_O, "ScXMLNotOpExprDataObj_getTypeId(ScXMLNotOpExprDataObj self) -> SoType"},
	 { "ScXMLNotOpExprDataObj_createInstance", _wrap_ScXMLNotOpExprDataObj_createInstance, METH_NOARGS, "ScXMLNotOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLNotOpExprDataObj_initClass", _wrap_ScXMLNotOpExprDataObj_initClass, METH_NOARGS, "ScXMLNotOpExprDataObj_initClass()"},
	 { "ScXMLNotOpExprDataObj_cleanClass", _wrap_ScXMLNotOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLNotOpExprDataObj_cleanClass()"},
	 { "ScXMLNotOpExprDataObj_createFor", _wrap_ScXMLNotOpExprDataObj_createFor, METH_O, "ScXMLNotOpExprDataObj_createFor(ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLNotOpExprDataObj", _wrap_new_ScXMLNotOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLNotOpExprDataObj()\n"
		"new_ScXMLNotOpExprDataObj(ScXMLDataObj rhs) -> ScXMLNotOpExprDataObj\n"
		""},
	 { "delete_ScXMLNotOpExprDataObj", _wrap_delete_ScXMLNotOpExprDataObj, METH_O, "delete_ScXMLNotOpExprDataObj(ScXMLNotOpExprDataObj self)"},
	 { "ScXMLNotOpExprDataObj_setRHS", _wrap_ScXMLNotOpExprDataObj_setRHS, METH_VARARGS, "ScXMLNotOpExprDataObj_setRHS(ScXMLNotOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLNotOpExprDataObj_getRHS", _wrap_ScXMLNotOpExprDataObj_getRHS, METH_O, "ScXMLNotOpExprDataObj_getRHS(ScXMLNotOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLNotOpExprDataObj_swigregister", ScXMLNotOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLNotOpExprDataObj_swiginit", ScXMLNotOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLEqualsOpExprDataObj_getClassTypeId", _wrap_ScXMLEqualsOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLEqualsOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLEqualsOpExprDataObj_getTypeId", _wrap_ScXMLEqualsOpExprDataObj_getTypeId, METH_O, "ScXMLEqualsOpExprDataObj_getTypeId(ScXMLEqualsOpExprDataObj self) -> SoType"},
	 { "ScXMLEqualsOpExprDataObj_createInstance", _wrap_ScXMLEqualsOpExprDataObj_createInstance, METH_NOARGS, "ScXMLEqualsOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLEqualsOpExprDataObj_initClass", _wrap_ScXMLEqualsOpExprDataObj_initClass, METH_NOARGS, "ScXMLEqualsOpExprDataObj_initClass()"},
	 { "ScXMLEqualsOpExprDataObj_cleanClass", _wrap_ScXMLEqualsOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLEqualsOpExprDataObj_cleanClass()"},
	 { "ScXMLEqualsOpExprDataObj_createFor", _wrap_ScXMLEqualsOpExprDataObj_createFor, METH_VARARGS, "ScXMLEqualsOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLEqualsOpExprDataObj", _wrap_new_ScXMLEqualsOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLEqualsOpExprDataObj()\n"
		"new_ScXMLEqualsOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLEqualsOpExprDataObj\n"
		""},
	 { "delete_ScXMLEqualsOpExprDataObj", _wrap_delete_ScXMLEqualsOpExprDataObj, METH_O, "delete_ScXMLEqualsOpExprDataObj(ScXMLEqualsOpExprDataObj self)"},
	 { "ScXMLEqualsOpExprDataObj_setLHS", _wrap_ScXMLEqualsOpExprDataObj_setLHS, METH_VARARGS, "ScXMLEqualsOpExprDataObj_setLHS(ScXMLEqualsOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLEqualsOpExprDataObj_getLHS", _wrap_ScXMLEqualsOpExprDataObj_getLHS, METH_O, "ScXMLEqualsOpExprDataObj_getLHS(ScXMLEqualsOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLEqualsOpExprDataObj_setRHS", _wrap_ScXMLEqualsOpExprDataObj_setRHS, METH_VARARGS, "ScXMLEqualsOpExprDataObj_setRHS(ScXMLEqualsOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLEqualsOpExprDataObj_getRHS", _wrap_ScXMLEqualsOpExprDataObj_getRHS, METH_O, "ScXMLEqualsOpExprDataObj_getRHS(ScXMLEqualsOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLEqualsOpExprDataObj_swigregister", ScXMLEqualsOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLEqualsOpExprDataObj_swiginit", ScXMLEqualsOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLAddOpExprDataObj_getClassTypeId", _wrap_ScXMLAddOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLAddOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLAddOpExprDataObj_getTypeId", _wrap_ScXMLAddOpExprDataObj_getTypeId, METH_O, "ScXMLAddOpExprDataObj_getTypeId(ScXMLAddOpExprDataObj self) -> SoType"},
	 { "ScXMLAddOpExprDataObj_createInstance", _wrap_ScXMLAddOpExprDataObj_createInstance, METH_NOARGS, "ScXMLAddOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLAddOpExprDataObj_initClass", _wrap_ScXMLAddOpExprDataObj_initClass, METH_NOARGS, "ScXMLAddOpExprDataObj_initClass()"},
	 { "ScXMLAddOpExprDataObj_cleanClass", _wrap_ScXMLAddOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLAddOpExprDataObj_cleanClass()"},
	 { "ScXMLAddOpExprDataObj_createFor", _wrap_ScXMLAddOpExprDataObj_createFor, METH_VARARGS, "ScXMLAddOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLAddOpExprDataObj", _wrap_new_ScXMLAddOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLAddOpExprDataObj()\n"
		"new_ScXMLAddOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAddOpExprDataObj\n"
		""},
	 { "delete_ScXMLAddOpExprDataObj", _wrap_delete_ScXMLAddOpExprDataObj, METH_O, "delete_ScXMLAddOpExprDataObj(ScXMLAddOpExprDataObj self)"},
	 { "ScXMLAddOpExprDataObj_setLHS", _wrap_ScXMLAddOpExprDataObj_setLHS, METH_VARARGS, "ScXMLAddOpExprDataObj_setLHS(ScXMLAddOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLAddOpExprDataObj_getLHS", _wrap_ScXMLAddOpExprDataObj_getLHS, METH_O, "ScXMLAddOpExprDataObj_getLHS(ScXMLAddOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAddOpExprDataObj_setRHS", _wrap_ScXMLAddOpExprDataObj_setRHS, METH_VARARGS, "ScXMLAddOpExprDataObj_setRHS(ScXMLAddOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLAddOpExprDataObj_getRHS", _wrap_ScXMLAddOpExprDataObj_getRHS, METH_O, "ScXMLAddOpExprDataObj_getRHS(ScXMLAddOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAddOpExprDataObj_swigregister", ScXMLAddOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLAddOpExprDataObj_swiginit", ScXMLAddOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLSubtractOpExprDataObj_getClassTypeId", _wrap_ScXMLSubtractOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLSubtractOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLSubtractOpExprDataObj_getTypeId", _wrap_ScXMLSubtractOpExprDataObj_getTypeId, METH_O, "ScXMLSubtractOpExprDataObj_getTypeId(ScXMLSubtractOpExprDataObj self) -> SoType"},
	 { "ScXMLSubtractOpExprDataObj_createInstance", _wrap_ScXMLSubtractOpExprDataObj_createInstance, METH_NOARGS, "ScXMLSubtractOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLSubtractOpExprDataObj_initClass", _wrap_ScXMLSubtractOpExprDataObj_initClass, METH_NOARGS, "ScXMLSubtractOpExprDataObj_initClass()"},
	 { "ScXMLSubtractOpExprDataObj_cleanClass", _wrap_ScXMLSubtractOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLSubtractOpExprDataObj_cleanClass()"},
	 { "ScXMLSubtractOpExprDataObj_createFor", _wrap_ScXMLSubtractOpExprDataObj_createFor, METH_VARARGS, "ScXMLSubtractOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLSubtractOpExprDataObj", _wrap_new_ScXMLSubtractOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLSubtractOpExprDataObj()\n"
		"new_ScXMLSubtractOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLSubtractOpExprDataObj\n"
		""},
	 { "delete_ScXMLSubtractOpExprDataObj", _wrap_delete_ScXMLSubtractOpExprDataObj, METH_O, "delete_ScXMLSubtractOpExprDataObj(ScXMLSubtractOpExprDataObj self)"},
	 { "ScXMLSubtractOpExprDataObj_setLHS", _wrap_ScXMLSubtractOpExprDataObj_setLHS, METH_VARARGS, "ScXMLSubtractOpExprDataObj_setLHS(ScXMLSubtractOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLSubtractOpExprDataObj_getLHS", _wrap_ScXMLSubtractOpExprDataObj_getLHS, METH_O, "ScXMLSubtractOpExprDataObj_getLHS(ScXMLSubtractOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLSubtractOpExprDataObj_setRHS", _wrap_ScXMLSubtractOpExprDataObj_setRHS, METH_VARARGS, "ScXMLSubtractOpExprDataObj_setRHS(ScXMLSubtractOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLSubtractOpExprDataObj_getRHS", _wrap_ScXMLSubtractOpExprDataObj_getRHS, METH_O, "ScXMLSubtractOpExprDataObj_getRHS(ScXMLSubtractOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLSubtractOpExprDataObj_swigregister", ScXMLSubtractOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLSubtractOpExprDataObj_swiginit", ScXMLSubtractOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLMultiplyOpExprDataObj_getClassTypeId", _wrap_ScXMLMultiplyOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLMultiplyOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLMultiplyOpExprDataObj_getTypeId", _wrap_ScXMLMultiplyOpExprDataObj_getTypeId, METH_O, "ScXMLMultiplyOpExprDataObj_getTypeId(ScXMLMultiplyOpExprDataObj self) -> SoType"},
	 { "ScXMLMultiplyOpExprDataObj_createInstance", _wrap_ScXMLMultiplyOpExprDataObj_createInstance, METH_NOARGS, "ScXMLMultiplyOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLMultiplyOpExprDataObj_initClass", _wrap_ScXMLMultiplyOpExprDataObj_initClass, METH_NOARGS, "ScXMLMultiplyOpExprDataObj_initClass()"},
	 { "ScXMLMultiplyOpExprDataObj_cleanClass", _wrap_ScXMLMultiplyOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLMultiplyOpExprDataObj_cleanClass()"},
	 { "ScXMLMultiplyOpExprDataObj_createFor", _wrap_ScXMLMultiplyOpExprDataObj_createFor, METH_VARARGS, "ScXMLMultiplyOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLMultiplyOpExprDataObj", _wrap_new_ScXMLMultiplyOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLMultiplyOpExprDataObj()\n"
		"new_ScXMLMultiplyOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLMultiplyOpExprDataObj\n"
		""},
	 { "delete_ScXMLMultiplyOpExprDataObj", _wrap_delete_ScXMLMultiplyOpExprDataObj, METH_O, "delete_ScXMLMultiplyOpExprDataObj(ScXMLMultiplyOpExprDataObj self)"},
	 { "ScXMLMultiplyOpExprDataObj_setLHS", _wrap_ScXMLMultiplyOpExprDataObj_setLHS, METH_VARARGS, "ScXMLMultiplyOpExprDataObj_setLHS(ScXMLMultiplyOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLMultiplyOpExprDataObj_getLHS", _wrap_ScXMLMultiplyOpExprDataObj_getLHS, METH_O, "ScXMLMultiplyOpExprDataObj_getLHS(ScXMLMultiplyOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLMultiplyOpExprDataObj_setRHS", _wrap_ScXMLMultiplyOpExprDataObj_setRHS, METH_VARARGS, "ScXMLMultiplyOpExprDataObj_setRHS(ScXMLMultiplyOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLMultiplyOpExprDataObj_getRHS", _wrap_ScXMLMultiplyOpExprDataObj_getRHS, METH_O, "ScXMLMultiplyOpExprDataObj_getRHS(ScXMLMultiplyOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLMultiplyOpExprDataObj_swigregister", ScXMLMultiplyOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLMultiplyOpExprDataObj_swiginit", ScXMLMultiplyOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLDivideOpExprDataObj_getClassTypeId", _wrap_ScXMLDivideOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLDivideOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLDivideOpExprDataObj_getTypeId", _wrap_ScXMLDivideOpExprDataObj_getTypeId, METH_O, "ScXMLDivideOpExprDataObj_getTypeId(ScXMLDivideOpExprDataObj self) -> SoType"},
	 { "ScXMLDivideOpExprDataObj_createInstance", _wrap_ScXMLDivideOpExprDataObj_createInstance, METH_NOARGS, "ScXMLDivideOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLDivideOpExprDataObj_initClass", _wrap_ScXMLDivideOpExprDataObj_initClass, METH_NOARGS, "ScXMLDivideOpExprDataObj_initClass()"},
	 { "ScXMLDivideOpExprDataObj_cleanClass", _wrap_ScXMLDivideOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLDivideOpExprDataObj_cleanClass()"},
	 { "ScXMLDivideOpExprDataObj_createFor", _wrap_ScXMLDivideOpExprDataObj_createFor, METH_VARARGS, "ScXMLDivideOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLDivideOpExprDataObj", _wrap_new_ScXMLDivideOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLDivideOpExprDataObj()\n"
		"new_ScXMLDivideOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDivideOpExprDataObj\n"
		""},
	 { "delete_ScXMLDivideOpExprDataObj", _wrap_delete_ScXMLDivideOpExprDataObj, METH_O, "delete_ScXMLDivideOpExprDataObj(ScXMLDivideOpExprDataObj self)"},
	 { "ScXMLDivideOpExprDataObj_setLHS", _wrap_ScXMLDivideOpExprDataObj_setLHS, METH_VARARGS, "ScXMLDivideOpExprDataObj_setLHS(ScXMLDivideOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLDivideOpExprDataObj_getLHS", _wrap_ScXMLDivideOpExprDataObj_getLHS, METH_O, "ScXMLDivideOpExprDataObj_getLHS(ScXMLDivideOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLDivideOpExprDataObj_setRHS", _wrap_ScXMLDivideOpExprDataObj_setRHS, METH_VARARGS, "ScXMLDivideOpExprDataObj_setRHS(ScXMLDivideOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLDivideOpExprDataObj_getRHS", _wrap_ScXMLDivideOpExprDataObj_getRHS, METH_O, "ScXMLDivideOpExprDataObj_getRHS(ScXMLDivideOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLDivideOpExprDataObj_swigregister", ScXMLDivideOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLDivideOpExprDataObj_swiginit", ScXMLDivideOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLNegateOpExprDataObj_getClassTypeId", _wrap_ScXMLNegateOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLNegateOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLNegateOpExprDataObj_getTypeId", _wrap_ScXMLNegateOpExprDataObj_getTypeId, METH_O, "ScXMLNegateOpExprDataObj_getTypeId(ScXMLNegateOpExprDataObj self) -> SoType"},
	 { "ScXMLNegateOpExprDataObj_createInstance", _wrap_ScXMLNegateOpExprDataObj_createInstance, METH_NOARGS, "ScXMLNegateOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLNegateOpExprDataObj_initClass", _wrap_ScXMLNegateOpExprDataObj_initClass, METH_NOARGS, "ScXMLNegateOpExprDataObj_initClass()"},
	 { "ScXMLNegateOpExprDataObj_cleanClass", _wrap_ScXMLNegateOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLNegateOpExprDataObj_cleanClass()"},
	 { "ScXMLNegateOpExprDataObj_createFor", _wrap_ScXMLNegateOpExprDataObj_createFor, METH_O, "ScXMLNegateOpExprDataObj_createFor(ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLNegateOpExprDataObj", _wrap_new_ScXMLNegateOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLNegateOpExprDataObj()\n"
		"new_ScXMLNegateOpExprDataObj(ScXMLDataObj rhs) -> ScXMLNegateOpExprDataObj\n"
		""},
	 { "delete_ScXMLNegateOpExprDataObj", _wrap_delete_ScXMLNegateOpExprDataObj, METH_O, "delete_ScXMLNegateOpExprDataObj(ScXMLNegateOpExprDataObj self)"},
	 { "ScXMLNegateOpExprDataObj_setRHS", _wrap_ScXMLNegateOpExprDataObj_setRHS, METH_VARARGS, "ScXMLNegateOpExprDataObj_setRHS(ScXMLNegateOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLNegateOpExprDataObj_getRHS", _wrap_ScXMLNegateOpExprDataObj_getRHS, METH_O, "ScXMLNegateOpExprDataObj_getRHS(ScXMLNegateOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLNegateOpExprDataObj_swigregister", ScXMLNegateOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLNegateOpExprDataObj_swiginit", ScXMLNegateOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinEvaluator_getClassTypeId", _wrap_ScXMLCoinEvaluator_getClassTypeId, METH_NOARGS, "ScXMLCoinEvaluator_getClassTypeId() -> SoType"},
	 { "ScXMLCoinEvaluator_getTypeId", _wrap_ScXMLCoinEvaluator_getTypeId, METH_O, "ScXMLCoinEvaluator_getTypeId(ScXMLCoinEvaluator self) -> SoType"},
	 { "ScXMLCoinEvaluator_createInstance", _wrap_ScXMLCoinEvaluator_createInstance, METH_NOARGS, "ScXMLCoinEvaluator_createInstance() -> void *"},
	 { "ScXMLCoinEvaluator_initClass", _wrap_ScXMLCoinEvaluator_initClass, METH_NOARGS, "ScXMLCoinEvaluator_initClass()"},
	 { "ScXMLCoinEvaluator_cleanClass", _wrap_ScXMLCoinEvaluator_cleanClass, METH_NOARGS, "ScXMLCoinEvaluator_cleanClass()"},
	 { "new_ScXMLCoinEvaluator", _wrap_new_ScXMLCoinEvaluator, METH_NOARGS, "new_ScXMLCoinEvaluator() -> ScXMLCoinEvaluator"},
	 { "delete_ScXMLCoinEvaluator", _wrap_delete_ScXMLCoinEvaluator, METH_O, "delete_ScXMLCoinEvaluator(ScXMLCoinEvaluator self)"},
	 { "ScXMLCoinEvaluator_setStateMachine", _wrap_ScXMLCoinEvaluator_setStateMachine, METH_VARARGS, "ScXMLCoinEvaluator_setStateMachine(ScXMLCoinEvaluator self, ScXMLStateMachine sm)"},
	 { "ScXMLCoinEvaluator_evaluate", _wrap_ScXMLCoinEvaluator_evaluate, METH_VARARGS, "ScXMLCoinEvaluator_evaluate(ScXMLCoinEvaluator self, char const * expression) -> ScXMLDataObj"},
	 { "ScXMLCoinEvaluator_setAtLocation", _wrap_ScXMLCoinEvaluator_setAtLocation, METH_VARARGS, "ScXMLCoinEvaluator_setAtLocation(ScXMLCoinEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"},
	 { "ScXMLCoinEvaluator_locate", _wrap_ScXMLCoinEvaluator_locate, METH_VARARGS, "ScXMLCoinEvaluator_locate(ScXMLCoinEvaluator self, char const * location) -> ScXMLDataObj"},
	 { "ScXMLCoinEvaluator_clearTemporaryVariables", _wrap_ScXMLCoinEvaluator_clearTemporaryVariables, METH_O, "ScXMLCoinEvaluator_clearTemporaryVariables(ScXMLCoinEvaluator self)"},
	 { "ScXMLCoinEvaluator_dumpTemporaries", _wrap_ScXMLCoinEvaluator_dumpTemporaries, METH_O, "ScXMLCoinEvaluator_dumpTemporaries(ScXMLCoinEvaluator self)"},
	 { "ScXMLCoinEvaluator_swigregister", ScXMLCoinEvaluator_swigregister, METH_O, NULL},
	 { "ScXMLCoinEvaluator_swiginit", ScXMLCoinEvaluator_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinEqualsOpExprDataObj_getClassTypeId", _wrap_ScXMLCoinEqualsOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinEqualsOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinEqualsOpExprDataObj_getTypeId", _wrap_ScXMLCoinEqualsOpExprDataObj_getTypeId, METH_O, "ScXMLCoinEqualsOpExprDataObj_getTypeId(ScXMLCoinEqualsOpExprDataObj self) -> SoType"},
	 { "ScXMLCoinEqualsOpExprDataObj_createInstance", _wrap_ScXMLCoinEqualsOpExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinEqualsOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinEqualsOpExprDataObj_initClass", _wrap_ScXMLCoinEqualsOpExprDataObj_initClass, METH_NOARGS, "ScXMLCoinEqualsOpExprDataObj_initClass()"},
	 { "ScXMLCoinEqualsOpExprDataObj_cleanClass", _wrap_ScXMLCoinEqualsOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinEqualsOpExprDataObj_cleanClass()"},
	 { "new_ScXMLCoinEqualsOpExprDataObj", _wrap_new_ScXMLCoinEqualsOpExprDataObj, METH_NOARGS, "new_ScXMLCoinEqualsOpExprDataObj() -> ScXMLCoinEqualsOpExprDataObj"},
	 { "delete_ScXMLCoinEqualsOpExprDataObj", _wrap_delete_ScXMLCoinEqualsOpExprDataObj, METH_O, "delete_ScXMLCoinEqualsOpExprDataObj(ScXMLCoinEqualsOpExprDataObj self)"},
	 { "ScXMLCoinEqualsOpExprDataObj_swigregister", ScXMLCoinEqualsOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinEqualsOpExprDataObj_swiginit", ScXMLCoinEqualsOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinAddOpExprDataObj_getClassTypeId", _wrap_ScXMLCoinAddOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinAddOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinAddOpExprDataObj_getTypeId", _wrap_ScXMLCoinAddOpExprDataObj_getTypeId, METH_O, "ScXMLCoinAddOpExprDataObj_getTypeId(ScXMLCoinAddOpExprDataObj self) -> SoType"},
	 { "ScXMLCoinAddOpExprDataObj_createInstance", _wrap_ScXMLCoinAddOpExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinAddOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinAddOpExprDataObj_initClass", _wrap_ScXMLCoinAddOpExprDataObj_initClass, METH_NOARGS, "ScXMLCoinAddOpExprDataObj_initClass()"},
	 { "ScXMLCoinAddOpExprDataObj_cleanClass", _wrap_ScXMLCoinAddOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinAddOpExprDataObj_cleanClass()"},
	 { "new_ScXMLCoinAddOpExprDataObj", _wrap_new_ScXMLCoinAddOpExprDataObj, METH_NOARGS, "new_ScXMLCoinAddOpExprDataObj() -> ScXMLCoinAddOpExprDataObj"},
	 { "delete_ScXMLCoinAddOpExprDataObj", _wrap_delete_ScXMLCoinAddOpExprDataObj, METH_O, "delete_ScXMLCoinAddOpExprDataObj(ScXMLCoinAddOpExprDataObj self)"},
	 { "ScXMLCoinAddOpExprDataObj_swigregister", ScXMLCoinAddOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinAddOpExprDataObj_swiginit", ScXMLCoinAddOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinSubtractOpExprDataObj_getClassTypeId", _wrap_ScXMLCoinSubtractOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinSubtractOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinSubtractOpExprDataObj_getTypeId", _wrap_ScXMLCoinSubtractOpExprDataObj_getTypeId, METH_O, "ScXMLCoinSubtractOpExprDataObj_getTypeId(ScXMLCoinSubtractOpExprDataObj self) -> SoType"},
	 { "ScXMLCoinSubtractOpExprDataObj_createInstance", _wrap_ScXMLCoinSubtractOpExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinSubtractOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinSubtractOpExprDataObj_initClass", _wrap_ScXMLCoinSubtractOpExprDataObj_initClass, METH_NOARGS, "ScXMLCoinSubtractOpExprDataObj_initClass()"},
	 { "ScXMLCoinSubtractOpExprDataObj_cleanClass", _wrap_ScXMLCoinSubtractOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinSubtractOpExprDataObj_cleanClass()"},
	 { "ScXMLCoinSubtractOpExprDataObj_createFor", _wrap_ScXMLCoinSubtractOpExprDataObj_createFor, METH_VARARGS, "ScXMLCoinSubtractOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLCoinSubtractOpExprDataObj", _wrap_new_ScXMLCoinSubtractOpExprDataObj, METH_NOARGS, "new_ScXMLCoinSubtractOpExprDataObj() -> ScXMLCoinSubtractOpExprDataObj"},
	 { "delete_ScXMLCoinSubtractOpExprDataObj", _wrap_delete_ScXMLCoinSubtractOpExprDataObj, METH_O, "delete_ScXMLCoinSubtractOpExprDataObj(ScXMLCoinSubtractOpExprDataObj self)"},
	 { "ScXMLCoinSubtractOpExprDataObj_swigregister", ScXMLCoinSubtractOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinSubtractOpExprDataObj_swiginit", ScXMLCoinSubtractOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinMultiplyOpExprDataObj_getClassTypeId", _wrap_ScXMLCoinMultiplyOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinMultiplyOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinMultiplyOpExprDataObj_getTypeId", _wrap_ScXMLCoinMultiplyOpExprDataObj_getTypeId, METH_O, "ScXMLCoinMultiplyOpExprDataObj_getTypeId(ScXMLCoinMultiplyOpExprDataObj self) -> SoType"},
	 { "ScXMLCoinMultiplyOpExprDataObj_createInstance", _wrap_ScXMLCoinMultiplyOpExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinMultiplyOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinMultiplyOpExprDataObj_initClass", _wrap_ScXMLCoinMultiplyOpExprDataObj_initClass, METH_NOARGS, "ScXMLCoinMultiplyOpExprDataObj_initClass()"},
	 { "ScXMLCoinMultiplyOpExprDataObj_cleanClass", _wrap_ScXMLCoinMultiplyOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinMultiplyOpExprDataObj_cleanClass()"},
	 { "new_ScXMLCoinMultiplyOpExprDataObj", _wrap_new_ScXMLCoinMultiplyOpExprDataObj, METH_NOARGS, "new_ScXMLCoinMultiplyOpExprDataObj() -> ScXMLCoinMultiplyOpExprDataObj"},
	 { "delete_ScXMLCoinMultiplyOpExprDataObj", _wrap_delete_ScXMLCoinMultiplyOpExprDataObj, METH_O, "delete_ScXMLCoinMultiplyOpExprDataObj(ScXMLCoinMultiplyOpExprDataObj self)"},
	 { "ScXMLCoinMultiplyOpExprDataObj_swigregister", ScXMLCoinMultiplyOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinMultiplyOpExprDataObj_swiginit", ScXMLCoinMultiplyOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinDivideOpExprDataObj_getClassTypeId", _wrap_ScXMLCoinDivideOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinDivideOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinDivideOpExprDataObj_getTypeId", _wrap_ScXMLCoinDivideOpExprDataObj_getTypeId, METH_O, "ScXMLCoinDivideOpExprDataObj_getTypeId(ScXMLCoinDivideOpExprDataObj self) -> SoType"},
	 { "ScXMLCoinDivideOpExprDataObj_createInstance", _wrap_ScXMLCoinDivideOpExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinDivideOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinDivideOpExprDataObj_initClass", _wrap_ScXMLCoinDivideOpExprDataObj_initClass, METH_NOARGS, "ScXMLCoinDivideOpExprDataObj_initClass()"},
	 { "ScXMLCoinDivideOpExprDataObj_cleanClass", _wrap_ScXMLCoinDivideOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinDivideOpExprDataObj_cleanClass()"},
	 { "new_ScXMLCoinDivideOpExprDataObj", _wrap_new_ScXMLCoinDivideOpExprDataObj, METH_NOARGS, "new_ScXMLCoinDivideOpExprDataObj() -> ScXMLCoinDivideOpExprDataObj"},
	 { "delete_ScXMLCoinDivideOpExprDataObj", _wrap_delete_ScXMLCoinDivideOpExprDataObj, METH_O, "delete_ScXMLCoinDivideOpExprDataObj(ScXMLCoinDivideOpExprDataObj self)"},
	 { "ScXMLCoinDivideOpExprDataObj_swigregister", ScXMLCoinDivideOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinDivideOpExprDataObj_swiginit", ScXMLCoinDivideOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLCoinLengthFuncExprDataObj_getClassTypeId", _wrap_ScXMLCoinLengthFuncExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLCoinLengthFuncExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLCoinLengthFuncExprDataObj_getTypeId", _wrap_ScXMLCoinLengthFuncExprDataObj_getTypeId, METH_O, "ScXMLCoinLengthFuncExprDataObj_getTypeId(ScXMLCoinLengthFuncExprDataObj self) -> SoType"},
	 { "ScXMLCoinLengthFuncExprDataObj_createInstance", _wrap_ScXMLCoinLengthFuncExprDataObj_createInstance, METH_NOARGS, "ScXMLCoinLengthFuncExprDataObj_createInstance() -> void *"},
	 { "ScXMLCoinLengthFuncExprDataObj_initClass", _wrap_ScXMLCoinLengthFuncExprDataObj_initClass, METH_NOARGS, "ScXMLCoinLengthFuncExprDataObj_initClass()"},
	 { "ScXMLCoinLengthFuncExprDataObj_cleanClass", _wrap_ScXMLCoinLengthFuncExprDataObj_cleanClass, METH_NOARGS, "ScXMLCoinLengthFuncExprDataObj_cleanClass()"},
	 { "ScXMLCoinLengthFuncExprDataObj_createFor", _wrap_ScXMLCoinLengthFuncExprDataObj_createFor, METH_O, "ScXMLCoinLengthFuncExprDataObj_createFor(ScXMLDataObj obj) -> ScXMLDataObj"},
	 { "new_ScXMLCoinLengthFuncExprDataObj", _wrap_new_ScXMLCoinLengthFuncExprDataObj, METH_VARARGS, "\n"
		"ScXMLCoinLengthFuncExprDataObj()\n"
		"new_ScXMLCoinLengthFuncExprDataObj(ScXMLDataObj obj) -> ScXMLCoinLengthFuncExprDataObj\n"
		""},
	 { "delete_ScXMLCoinLengthFuncExprDataObj", _wrap_delete_ScXMLCoinLengthFuncExprDataObj, METH_O, "delete_ScXMLCoinLengthFuncExprDataObj(ScXMLCoinLengthFuncExprDataObj self)"},
	 { "ScXMLCoinLengthFuncExprDataObj_setExpr", _wrap_ScXMLCoinLengthFuncExprDataObj_setExpr, METH_VARARGS, "ScXMLCoinLengthFuncExprDataObj_setExpr(ScXMLCoinLengthFuncExprDataObj self, ScXMLDataObj obj)"},
	 { "ScXMLCoinLengthFuncExprDataObj_getExpr", _wrap_ScXMLCoinLengthFuncExprDataObj_getExpr, METH_O, "ScXMLCoinLengthFuncExprDataObj_getExpr(ScXMLCoinLengthFuncExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLCoinLengthFuncExprDataObj_swigregister", ScXMLCoinLengthFuncExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLCoinLengthFuncExprDataObj_swiginit", ScXMLCoinLengthFuncExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLContentElt_getElementReader", _wrap_ScXMLContentElt_getElementReader, METH_NOARGS, "ScXMLContentElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLContentElt_getClassTypeId", _wrap_ScXMLContentElt_getClassTypeId, METH_NOARGS, "ScXMLContentElt_getClassTypeId() -> SoType"},
	 { "ScXMLContentElt_getTypeId", _wrap_ScXMLContentElt_getTypeId, METH_O, "ScXMLContentElt_getTypeId(ScXMLContentElt self) -> SoType"},
	 { "ScXMLContentElt_createInstance", _wrap_ScXMLContentElt_createInstance, METH_NOARGS, "ScXMLContentElt_createInstance() -> void *"},
	 { "ScXMLContentElt_initClass", _wrap_ScXMLContentElt_initClass, METH_NOARGS, "ScXMLContentElt_initClass()"},
	 { "ScXMLContentElt_cleanClass", _wrap_ScXMLContentElt_cleanClass, METH_NOARGS, "ScXMLContentElt_cleanClass()"},
	 { "new_ScXMLContentElt", _wrap_new_ScXMLContentElt, METH_NOARGS, "new_ScXMLContentElt() -> ScXMLContentElt"},
	 { "delete_ScXMLContentElt", _wrap_delete_ScXMLContentElt, METH_O, "delete_ScXMLContentElt(ScXMLContentElt self)"},
	 { "ScXMLContentElt_copyContents", _wrap_ScXMLContentElt_copyContents, METH_VARARGS, "ScXMLContentElt_copyContents(ScXMLContentElt self, ScXMLElt rhs)"},
	 { "ScXMLContentElt_swigregister", ScXMLContentElt_swigregister, METH_O, NULL},
	 { "ScXMLContentElt_swiginit", ScXMLContentElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLDataElt_getElementReader", _wrap_ScXMLDataElt_getElementReader, METH_NOARGS, "ScXMLDataElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLDataElt_getClassTypeId", _wrap_ScXMLDataElt_getClassTypeId, METH_NOARGS, "ScXMLDataElt_getClassTypeId() -> SoType"},
	 { "ScXMLDataElt_getTypeId", _wrap_ScXMLDataElt_getTypeId, METH_O, "ScXMLDataElt_getTypeId(ScXMLDataElt self) -> SoType"},
	 { "ScXMLDataElt_createInstance", _wrap_ScXMLDataElt_createInstance, METH_NOARGS, "ScXMLDataElt_createInstance() -> void *"},
	 { "ScXMLDataElt_initClass", _wrap_ScXMLDataElt_initClass, METH_NOARGS, "ScXMLDataElt_initClass()"},
	 { "ScXMLDataElt_cleanClass", _wrap_ScXMLDataElt_cleanClass, METH_NOARGS, "ScXMLDataElt_cleanClass()"},
	 { "new_ScXMLDataElt", _wrap_new_ScXMLDataElt, METH_NOARGS, "new_ScXMLDataElt() -> ScXMLDataElt"},
	 { "delete_ScXMLDataElt", _wrap_delete_ScXMLDataElt, METH_O, "delete_ScXMLDataElt(ScXMLDataElt self)"},
	 { "ScXMLDataElt_setIDAttribute", _wrap_ScXMLDataElt_setIDAttribute, METH_VARARGS, "ScXMLDataElt_setIDAttribute(ScXMLDataElt self, char const * ID)"},
	 { "ScXMLDataElt_getIDAttribute", _wrap_ScXMLDataElt_getIDAttribute, METH_O, "ScXMLDataElt_getIDAttribute(ScXMLDataElt self) -> char const *"},
	 { "ScXMLDataElt_setSrcAttribute", _wrap_ScXMLDataElt_setSrcAttribute, METH_VARARGS, "ScXMLDataElt_setSrcAttribute(ScXMLDataElt self, char const * src)"},
	 { "ScXMLDataElt_getSrcAttribute", _wrap_ScXMLDataElt_getSrcAttribute, METH_O, "ScXMLDataElt_getSrcAttribute(ScXMLDataElt self) -> char const *"},
	 { "ScXMLDataElt_setExprAttribute", _wrap_ScXMLDataElt_setExprAttribute, METH_VARARGS, "ScXMLDataElt_setExprAttribute(ScXMLDataElt self, char const * expr)"},
	 { "ScXMLDataElt_getExprAttribute", _wrap_ScXMLDataElt_getExprAttribute, METH_O, "ScXMLDataElt_getExprAttribute(ScXMLDataElt self) -> char const *"},
	 { "ScXMLDataElt_handleXMLAttributes", _wrap_ScXMLDataElt_handleXMLAttributes, METH_O, "ScXMLDataElt_handleXMLAttributes(ScXMLDataElt self) -> SbBool"},
	 { "ScXMLDataElt_copyContents", _wrap_ScXMLDataElt_copyContents, METH_VARARGS, "ScXMLDataElt_copyContents(ScXMLDataElt self, ScXMLElt rhs)"},
	 { "ScXMLDataElt_search", _wrap_ScXMLDataElt_search, METH_VARARGS, "ScXMLDataElt_search(ScXMLDataElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLDataElt_setValueObj", _wrap_ScXMLDataElt_setValueObj, METH_VARARGS, "ScXMLDataElt_setValueObj(ScXMLDataElt self, ScXMLDataObj value)"},
	 { "ScXMLDataElt_getValueObj", _wrap_ScXMLDataElt_getValueObj, METH_O, "ScXMLDataElt_getValueObj(ScXMLDataElt self) -> ScXMLDataObj"},
	 { "ScXMLDataElt_swigregister", ScXMLDataElt_swigregister, METH_O, NULL},
	 { "ScXMLDataElt_swiginit", ScXMLDataElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLDataModelElt_getElementReader", _wrap_ScXMLDataModelElt_getElementReader, METH_NOARGS, "ScXMLDataModelElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLDataModelElt_getClassTypeId", _wrap_ScXMLDataModelElt_getClassTypeId, METH_NOARGS, "ScXMLDataModelElt_getClassTypeId() -> SoType"},
	 { "ScXMLDataModelElt_getTypeId", _wrap_ScXMLDataModelElt_getTypeId, METH_O, "ScXMLDataModelElt_getTypeId(ScXMLDataModelElt self) -> SoType"},
	 { "ScXMLDataModelElt_createInstance", _wrap_ScXMLDataModelElt_createInstance, METH_NOARGS, "ScXMLDataModelElt_createInstance() -> void *"},
	 { "ScXMLDataModelElt_initClass", _wrap_ScXMLDataModelElt_initClass, METH_NOARGS, "ScXMLDataModelElt_initClass()"},
	 { "ScXMLDataModelElt_cleanClass", _wrap_ScXMLDataModelElt_cleanClass, METH_NOARGS, "ScXMLDataModelElt_cleanClass()"},
	 { "new_ScXMLDataModelElt", _wrap_new_ScXMLDataModelElt, METH_NOARGS, "new_ScXMLDataModelElt() -> ScXMLDataModelElt"},
	 { "delete_ScXMLDataModelElt", _wrap_delete_ScXMLDataModelElt, METH_O, "delete_ScXMLDataModelElt(ScXMLDataModelElt self)"},
	 { "ScXMLDataModelElt_setSchemaAttribute", _wrap_ScXMLDataModelElt_setSchemaAttribute, METH_VARARGS, "ScXMLDataModelElt_setSchemaAttribute(ScXMLDataModelElt self, char const * schema)"},
	 { "ScXMLDataModelElt_getSchemaAttribute", _wrap_ScXMLDataModelElt_getSchemaAttribute, METH_O, "ScXMLDataModelElt_getSchemaAttribute(ScXMLDataModelElt self) -> char const *"},
	 { "ScXMLDataModelElt_handleXMLAttributes", _wrap_ScXMLDataModelElt_handleXMLAttributes, METH_O, "ScXMLDataModelElt_handleXMLAttributes(ScXMLDataModelElt self) -> SbBool"},
	 { "ScXMLDataModelElt_copyContents", _wrap_ScXMLDataModelElt_copyContents, METH_VARARGS, "ScXMLDataModelElt_copyContents(ScXMLDataModelElt self, ScXMLElt rhs)"},
	 { "ScXMLDataModelElt_getNumData", _wrap_ScXMLDataModelElt_getNumData, METH_O, "ScXMLDataModelElt_getNumData(ScXMLDataModelElt self) -> int"},
	 { "ScXMLDataModelElt_getData", _wrap_ScXMLDataModelElt_getData, METH_VARARGS, "ScXMLDataModelElt_getData(ScXMLDataModelElt self, int idx) -> ScXMLDataElt"},
	 { "ScXMLDataModelElt_addData", _wrap_ScXMLDataModelElt_addData, METH_VARARGS, "ScXMLDataModelElt_addData(ScXMLDataModelElt self, ScXMLDataElt data)"},
	 { "ScXMLDataModelElt_removeData", _wrap_ScXMLDataModelElt_removeData, METH_VARARGS, "ScXMLDataModelElt_removeData(ScXMLDataModelElt self, ScXMLDataElt data)"},
	 { "ScXMLDataModelElt_clearAllData", _wrap_ScXMLDataModelElt_clearAllData, METH_O, "ScXMLDataModelElt_clearAllData(ScXMLDataModelElt self)"},
	 { "ScXMLDataModelElt_search", _wrap_ScXMLDataModelElt_search, METH_VARARGS, "ScXMLDataModelElt_search(ScXMLDataModelElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLDataModelElt_swigregister", ScXMLDataModelElt_swigregister, METH_O, NULL},
	 { "ScXMLDataModelElt_swiginit", ScXMLDataModelElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLDocument_getClassTypeId", _wrap_ScXMLDocument_getClassTypeId, METH_NOARGS, "ScXMLDocument_getClassTypeId() -> SoType"},
	 { "ScXMLDocument_getTypeId", _wrap_ScXMLDocument_getTypeId, METH_O, "ScXMLDocument_getTypeId(ScXMLDocument self) -> SoType"},
	 { "ScXMLDocument_createInstance", _wrap_ScXMLDocument_createInstance, METH_NOARGS, "ScXMLDocument_createInstance() -> void *"},
	 { "ScXMLDocument_initClass", _wrap_ScXMLDocument_initClass, METH_NOARGS, "ScXMLDocument_initClass()"},
	 { "ScXMLDocument_cleanClass", _wrap_ScXMLDocument_cleanClass, METH_NOARGS, "ScXMLDocument_cleanClass()"},
	 { "ScXMLDocument_readFile", _wrap_ScXMLDocument_readFile, METH_O, "ScXMLDocument_readFile(char const * filename) -> ScXMLDocument"},
	 { "ScXMLDocument_readBuffer", _wrap_ScXMLDocument_readBuffer, METH_O, "ScXMLDocument_readBuffer(SbByteBuffer buffer) -> ScXMLDocument"},
	 { "ScXMLDocument_readXMLData", _wrap_ScXMLDocument_readXMLData, METH_O, "ScXMLDocument_readXMLData(cc_xml_doc * xmldoc) -> ScXMLDocument"},
	 { "new_ScXMLDocument", _wrap_new_ScXMLDocument, METH_NOARGS, "new_ScXMLDocument() -> ScXMLDocument"},
	 { "delete_ScXMLDocument", _wrap_delete_ScXMLDocument, METH_O, "delete_ScXMLDocument(ScXMLDocument self)"},
	 { "ScXMLDocument_setFilename", _wrap_ScXMLDocument_setFilename, METH_VARARGS, "ScXMLDocument_setFilename(ScXMLDocument self, char const * filename)"},
	 { "ScXMLDocument_getFilename", _wrap_ScXMLDocument_getFilename, METH_O, "ScXMLDocument_getFilename(ScXMLDocument self) -> char const *"},
	 { "ScXMLDocument_setRoot", _wrap_ScXMLDocument_setRoot, METH_VARARGS, "ScXMLDocument_setRoot(ScXMLDocument self, ScXMLScxmlElt root)"},
	 { "ScXMLDocument_getRoot", _wrap_ScXMLDocument_getRoot, METH_O, "ScXMLDocument_getRoot(ScXMLDocument self) -> ScXMLScxmlElt"},
	 { "ScXMLDocument_getStateById", _wrap_ScXMLDocument_getStateById, METH_VARARGS, "ScXMLDocument_getStateById(ScXMLDocument self, SbName id) -> ScXMLAbstractStateElt"},
	 { "ScXMLDocument_getDataById", _wrap_ScXMLDocument_getDataById, METH_VARARGS, "ScXMLDocument_getDataById(ScXMLDocument self, SbName id) -> ScXMLDataElt"},
	 { "ScXMLDocument_swigregister", ScXMLDocument_swigregister, METH_O, NULL},
	 { "ScXMLDocument_swiginit", ScXMLDocument_swiginit, METH_VARARGS, NULL},
	 { "ScXMLECMAScriptEvaluator_getClassTypeId", _wrap_ScXMLECMAScriptEvaluator_getClassTypeId, METH_NOARGS, "ScXMLECMAScriptEvaluator_getClassTypeId() -> SoType"},
	 { "ScXMLECMAScriptEvaluator_getTypeId", _wrap_ScXMLECMAScriptEvaluator_getTypeId, METH_O, "ScXMLECMAScriptEvaluator_getTypeId(ScXMLECMAScriptEvaluator self) -> SoType"},
	 { "ScXMLECMAScriptEvaluator_createInstance", _wrap_ScXMLECMAScriptEvaluator_createInstance, METH_NOARGS, "ScXMLECMAScriptEvaluator_createInstance() -> void *"},
	 { "ScXMLECMAScriptEvaluator_initClass", _wrap_ScXMLECMAScriptEvaluator_initClass, METH_NOARGS, "ScXMLECMAScriptEvaluator_initClass()"},
	 { "ScXMLECMAScriptEvaluator_cleanClass", _wrap_ScXMLECMAScriptEvaluator_cleanClass, METH_NOARGS, "ScXMLECMAScriptEvaluator_cleanClass()"},
	 { "new_ScXMLECMAScriptEvaluator", _wrap_new_ScXMLECMAScriptEvaluator, METH_NOARGS, "new_ScXMLECMAScriptEvaluator() -> ScXMLECMAScriptEvaluator"},
	 { "delete_ScXMLECMAScriptEvaluator", _wrap_delete_ScXMLECMAScriptEvaluator, METH_O, "delete_ScXMLECMAScriptEvaluator(ScXMLECMAScriptEvaluator self)"},
	 { "ScXMLECMAScriptEvaluator_evaluate", _wrap_ScXMLECMAScriptEvaluator_evaluate, METH_VARARGS, "ScXMLECMAScriptEvaluator_evaluate(ScXMLECMAScriptEvaluator self, char const * expression) -> ScXMLDataObj"},
	 { "ScXMLECMAScriptEvaluator_setAtLocation", _wrap_ScXMLECMAScriptEvaluator_setAtLocation, METH_VARARGS, "ScXMLECMAScriptEvaluator_setAtLocation(ScXMLECMAScriptEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"},
	 { "ScXMLECMAScriptEvaluator_locate", _wrap_ScXMLECMAScriptEvaluator_locate, METH_VARARGS, "ScXMLECMAScriptEvaluator_locate(ScXMLECMAScriptEvaluator self, char const * location) -> ScXMLDataObj"},
	 { "ScXMLECMAScriptEvaluator_swigregister", ScXMLECMAScriptEvaluator_swigregister, METH_O, NULL},
	 { "ScXMLECMAScriptEvaluator_swiginit", ScXMLECMAScriptEvaluator_swiginit, METH_VARARGS, NULL},
	 { "ScXMLElseElt_getElementReader", _wrap_ScXMLElseElt_getElementReader, METH_NOARGS, "ScXMLElseElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLElseElt_getClassTypeId", _wrap_ScXMLElseElt_getClassTypeId, METH_NOARGS, "ScXMLElseElt_getClassTypeId() -> SoType"},
	 { "ScXMLElseElt_getTypeId", _wrap_ScXMLElseElt_getTypeId, METH_O, "ScXMLElseElt_getTypeId(ScXMLElseElt self) -> SoType"},
	 { "ScXMLElseElt_createInstance", _wrap_ScXMLElseElt_createInstance, METH_NOARGS, "ScXMLElseElt_createInstance() -> void *"},
	 { "ScXMLElseElt_initClass", _wrap_ScXMLElseElt_initClass, METH_NOARGS, "ScXMLElseElt_initClass()"},
	 { "ScXMLElseElt_cleanClass", _wrap_ScXMLElseElt_cleanClass, METH_NOARGS, "ScXMLElseElt_cleanClass()"},
	 { "new_ScXMLElseElt", _wrap_new_ScXMLElseElt, METH_NOARGS, "new_ScXMLElseElt() -> ScXMLElseElt"},
	 { "delete_ScXMLElseElt", _wrap_delete_ScXMLElseElt, METH_O, "delete_ScXMLElseElt(ScXMLElseElt self)"},
	 { "ScXMLElseElt_copyContents", _wrap_ScXMLElseElt_copyContents, METH_VARARGS, "ScXMLElseElt_copyContents(ScXMLElseElt self, ScXMLElt rhs)"},
	 { "ScXMLElseElt_swigregister", ScXMLElseElt_swigregister, METH_O, NULL},
	 { "ScXMLElseElt_swiginit", ScXMLElseElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLElseIfElt_getElementReader", _wrap_ScXMLElseIfElt_getElementReader, METH_NOARGS, "ScXMLElseIfElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLElseIfElt_getClassTypeId", _wrap_ScXMLElseIfElt_getClassTypeId, METH_NOARGS, "ScXMLElseIfElt_getClassTypeId() -> SoType"},
	 { "ScXMLElseIfElt_getTypeId", _wrap_ScXMLElseIfElt_getTypeId, METH_O, "ScXMLElseIfElt_getTypeId(ScXMLElseIfElt self) -> SoType"},
	 { "ScXMLElseIfElt_createInstance", _wrap_ScXMLElseIfElt_createInstance, METH_NOARGS, "ScXMLElseIfElt_createInstance() -> void *"},
	 { "ScXMLElseIfElt_initClass", _wrap_ScXMLElseIfElt_initClass, METH_NOARGS, "ScXMLElseIfElt_initClass()"},
	 { "ScXMLElseIfElt_cleanClass", _wrap_ScXMLElseIfElt_cleanClass, METH_NOARGS, "ScXMLElseIfElt_cleanClass()"},
	 { "new_ScXMLElseIfElt", _wrap_new_ScXMLElseIfElt, METH_NOARGS, "new_ScXMLElseIfElt() -> ScXMLElseIfElt"},
	 { "delete_ScXMLElseIfElt", _wrap_delete_ScXMLElseIfElt, METH_O, "delete_ScXMLElseIfElt(ScXMLElseIfElt self)"},
	 { "ScXMLElseIfElt_setCondAttribute", _wrap_ScXMLElseIfElt_setCondAttribute, METH_VARARGS, "ScXMLElseIfElt_setCondAttribute(ScXMLElseIfElt self, char const * cond)"},
	 { "ScXMLElseIfElt_getCondAttribute", _wrap_ScXMLElseIfElt_getCondAttribute, METH_O, "ScXMLElseIfElt_getCondAttribute(ScXMLElseIfElt self) -> char const *"},
	 { "ScXMLElseIfElt_handleXMLAttributes", _wrap_ScXMLElseIfElt_handleXMLAttributes, METH_O, "ScXMLElseIfElt_handleXMLAttributes(ScXMLElseIfElt self) -> SbBool"},
	 { "ScXMLElseIfElt_copyContents", _wrap_ScXMLElseIfElt_copyContents, METH_VARARGS, "ScXMLElseIfElt_copyContents(ScXMLElseIfElt self, ScXMLElt rhs)"},
	 { "ScXMLElseIfElt_search", _wrap_ScXMLElseIfElt_search, METH_VARARGS, "ScXMLElseIfElt_search(ScXMLElseIfElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLElseIfElt_swigregister", ScXMLElseIfElt_swigregister, METH_O, NULL},
	 { "ScXMLElseIfElt_swiginit", ScXMLElseIfElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLEvent_getClassTypeId", _wrap_ScXMLEvent_getClassTypeId, METH_NOARGS, "ScXMLEvent_getClassTypeId() -> SoType"},
	 { "ScXMLEvent_getTypeId", _wrap_ScXMLEvent_getTypeId, METH_O, "ScXMLEvent_getTypeId(ScXMLEvent self) -> SoType"},
	 { "ScXMLEvent_createInstance", _wrap_ScXMLEvent_createInstance, METH_NOARGS, "ScXMLEvent_createInstance() -> void *"},
	 { "ScXMLEvent_initClass", _wrap_ScXMLEvent_initClass, METH_NOARGS, "ScXMLEvent_initClass()"},
	 { "ScXMLEvent_cleanClass", _wrap_ScXMLEvent_cleanClass, METH_NOARGS, "ScXMLEvent_cleanClass()"},
	 { "new_ScXMLEvent", _wrap_new_ScXMLEvent, METH_NOARGS, "new_ScXMLEvent() -> ScXMLEvent"},
	 { "delete_ScXMLEvent", _wrap_delete_ScXMLEvent, METH_O, "delete_ScXMLEvent(ScXMLEvent self)"},
	 { "ScXMLEvent_setEventName", _wrap_ScXMLEvent_setEventName, METH_VARARGS, "ScXMLEvent_setEventName(ScXMLEvent self, SbName name)"},
	 { "ScXMLEvent_getEventName", _wrap_ScXMLEvent_getEventName, METH_O, "ScXMLEvent_getEventName(ScXMLEvent self) -> SbName"},
	 { "ScXMLEvent_clone", _wrap_ScXMLEvent_clone, METH_O, "ScXMLEvent_clone(ScXMLEvent self) -> ScXMLEvent"},
	 { "ScXMLEvent_setAssociation", _wrap_ScXMLEvent_setAssociation, METH_VARARGS, "ScXMLEvent_setAssociation(ScXMLEvent self, char const * key, char const * value)"},
	 { "ScXMLEvent_getAssociation", _wrap_ScXMLEvent_getAssociation, METH_VARARGS, "ScXMLEvent_getAssociation(ScXMLEvent self, char const * key) -> char const *"},
	 { "ScXMLEvent_getNumAssociations", _wrap_ScXMLEvent_getNumAssociations, METH_O, "ScXMLEvent_getNumAssociations(ScXMLEvent self) -> size_t"},
	 { "ScXMLEvent_getAssociationKeys", _wrap_ScXMLEvent_getAssociationKeys, METH_VARARGS, "ScXMLEvent_getAssociationKeys(ScXMLEvent self, SbList< char const * > & keys) -> size_t"},
	 { "ScXMLEvent_swigregister", ScXMLEvent_swigregister, METH_O, NULL},
	 { "ScXMLEvent_swiginit", ScXMLEvent_swiginit, METH_VARARGS, NULL},
	 { "ScXMLEventElt_getElementReader", _wrap_ScXMLEventElt_getElementReader, METH_NOARGS, "ScXMLEventElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLEventElt_getClassTypeId", _wrap_ScXMLEventElt_getClassTypeId, METH_NOARGS, "ScXMLEventElt_getClassTypeId() -> SoType"},
	 { "ScXMLEventElt_getTypeId", _wrap_ScXMLEventElt_getTypeId, METH_O, "ScXMLEventElt_getTypeId(ScXMLEventElt self) -> SoType"},
	 { "ScXMLEventElt_createInstance", _wrap_ScXMLEventElt_createInstance, METH_NOARGS, "ScXMLEventElt_createInstance() -> void *"},
	 { "ScXMLEventElt_initClass", _wrap_ScXMLEventElt_initClass, METH_NOARGS, "ScXMLEventElt_initClass()"},
	 { "ScXMLEventElt_cleanClass", _wrap_ScXMLEventElt_cleanClass, METH_NOARGS, "ScXMLEventElt_cleanClass()"},
	 { "new_ScXMLEventElt", _wrap_new_ScXMLEventElt, METH_NOARGS, "new_ScXMLEventElt() -> ScXMLEventElt"},
	 { "delete_ScXMLEventElt", _wrap_delete_ScXMLEventElt, METH_O, "delete_ScXMLEventElt(ScXMLEventElt self)"},
	 { "ScXMLEventElt_setNameAttribute", _wrap_ScXMLEventElt_setNameAttribute, METH_VARARGS, "ScXMLEventElt_setNameAttribute(ScXMLEventElt self, char const * name)"},
	 { "ScXMLEventElt_getNameAttribute", _wrap_ScXMLEventElt_getNameAttribute, METH_O, "ScXMLEventElt_getNameAttribute(ScXMLEventElt self) -> char const *"},
	 { "ScXMLEventElt_handleXMLAttributes", _wrap_ScXMLEventElt_handleXMLAttributes, METH_O, "ScXMLEventElt_handleXMLAttributes(ScXMLEventElt self) -> SbBool"},
	 { "ScXMLEventElt_copyContents", _wrap_ScXMLEventElt_copyContents, METH_VARARGS, "ScXMLEventElt_copyContents(ScXMLEventElt self, ScXMLElt rhs)"},
	 { "ScXMLEventElt_search", _wrap_ScXMLEventElt_search, METH_VARARGS, "ScXMLEventElt_search(ScXMLEventElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLEventElt_createEvent", _wrap_ScXMLEventElt_createEvent, METH_VARARGS, "ScXMLEventElt_createEvent(ScXMLEventElt self, ScXMLEventTarget host) -> ScXMLEvent"},
	 { "ScXMLEventElt_execute", _wrap_ScXMLEventElt_execute, METH_VARARGS, "ScXMLEventElt_execute(ScXMLEventElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLEventElt_swigregister", ScXMLEventElt_swigregister, METH_O, NULL},
	 { "ScXMLEventElt_swiginit", ScXMLEventElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLFinalElt_getElementReader", _wrap_ScXMLFinalElt_getElementReader, METH_NOARGS, "ScXMLFinalElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLFinalElt_getClassTypeId", _wrap_ScXMLFinalElt_getClassTypeId, METH_NOARGS, "ScXMLFinalElt_getClassTypeId() -> SoType"},
	 { "ScXMLFinalElt_getTypeId", _wrap_ScXMLFinalElt_getTypeId, METH_O, "ScXMLFinalElt_getTypeId(ScXMLFinalElt self) -> SoType"},
	 { "ScXMLFinalElt_createInstance", _wrap_ScXMLFinalElt_createInstance, METH_NOARGS, "ScXMLFinalElt_createInstance() -> void *"},
	 { "ScXMLFinalElt_initClass", _wrap_ScXMLFinalElt_initClass, METH_NOARGS, "ScXMLFinalElt_initClass()"},
	 { "ScXMLFinalElt_cleanClass", _wrap_ScXMLFinalElt_cleanClass, METH_NOARGS, "ScXMLFinalElt_cleanClass()"},
	 { "new_ScXMLFinalElt", _wrap_new_ScXMLFinalElt, METH_NOARGS, "new_ScXMLFinalElt() -> ScXMLFinalElt"},
	 { "delete_ScXMLFinalElt", _wrap_delete_ScXMLFinalElt, METH_O, "delete_ScXMLFinalElt(ScXMLFinalElt self)"},
	 { "ScXMLFinalElt_setOnEntry", _wrap_ScXMLFinalElt_setOnEntry, METH_VARARGS, "ScXMLFinalElt_setOnEntry(ScXMLFinalElt self, ScXMLOnEntryElt onentry)"},
	 { "ScXMLFinalElt_getOnEntry", _wrap_ScXMLFinalElt_getOnEntry, METH_O, "ScXMLFinalElt_getOnEntry(ScXMLFinalElt self) -> ScXMLOnEntryElt"},
	 { "ScXMLFinalElt_setOnExit", _wrap_ScXMLFinalElt_setOnExit, METH_VARARGS, "ScXMLFinalElt_setOnExit(ScXMLFinalElt self, ScXMLOnExitElt onexit)"},
	 { "ScXMLFinalElt_getOnExit", _wrap_ScXMLFinalElt_getOnExit, METH_O, "ScXMLFinalElt_getOnExit(ScXMLFinalElt self) -> ScXMLOnExitElt"},
	 { "ScXMLFinalElt_copyContents", _wrap_ScXMLFinalElt_copyContents, METH_VARARGS, "ScXMLFinalElt_copyContents(ScXMLFinalElt self, ScXMLElt rhs)"},
	 { "ScXMLFinalElt_search", _wrap_ScXMLFinalElt_search, METH_VARARGS, "ScXMLFinalElt_search(ScXMLFinalElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLFinalElt_swigregister", ScXMLFinalElt_swigregister, METH_O, NULL},
	 { "ScXMLFinalElt_swiginit", ScXMLFinalElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLFinalizeElt_getElementReader", _wrap_ScXMLFinalizeElt_getElementReader, METH_NOARGS, "ScXMLFinalizeElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLFinalizeElt_getClassTypeId", _wrap_ScXMLFinalizeElt_getClassTypeId, METH_NOARGS, "ScXMLFinalizeElt_getClassTypeId() -> SoType"},
	 { "ScXMLFinalizeElt_getTypeId", _wrap_ScXMLFinalizeElt_getTypeId, METH_O, "ScXMLFinalizeElt_getTypeId(ScXMLFinalizeElt self) -> SoType"},
	 { "ScXMLFinalizeElt_createInstance", _wrap_ScXMLFinalizeElt_createInstance, METH_NOARGS, "ScXMLFinalizeElt_createInstance() -> void *"},
	 { "ScXMLFinalizeElt_initClass", _wrap_ScXMLFinalizeElt_initClass, METH_NOARGS, "ScXMLFinalizeElt_initClass()"},
	 { "ScXMLFinalizeElt_cleanClass", _wrap_ScXMLFinalizeElt_cleanClass, METH_NOARGS, "ScXMLFinalizeElt_cleanClass()"},
	 { "new_ScXMLFinalizeElt", _wrap_new_ScXMLFinalizeElt, METH_NOARGS, "new_ScXMLFinalizeElt() -> ScXMLFinalizeElt"},
	 { "delete_ScXMLFinalizeElt", _wrap_delete_ScXMLFinalizeElt, METH_O, "delete_ScXMLFinalizeElt(ScXMLFinalizeElt self)"},
	 { "ScXMLFinalizeElt_copyContents", _wrap_ScXMLFinalizeElt_copyContents, METH_VARARGS, "ScXMLFinalizeElt_copyContents(ScXMLFinalizeElt self, ScXMLElt rhs)"},
	 { "ScXMLFinalizeElt_swigregister", ScXMLFinalizeElt_swigregister, METH_O, NULL},
	 { "ScXMLFinalizeElt_swiginit", ScXMLFinalizeElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLHistoryElt_getElementReader", _wrap_ScXMLHistoryElt_getElementReader, METH_NOARGS, "ScXMLHistoryElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLHistoryElt_getClassTypeId", _wrap_ScXMLHistoryElt_getClassTypeId, METH_NOARGS, "ScXMLHistoryElt_getClassTypeId() -> SoType"},
	 { "ScXMLHistoryElt_getTypeId", _wrap_ScXMLHistoryElt_getTypeId, METH_O, "ScXMLHistoryElt_getTypeId(ScXMLHistoryElt self) -> SoType"},
	 { "ScXMLHistoryElt_createInstance", _wrap_ScXMLHistoryElt_createInstance, METH_NOARGS, "ScXMLHistoryElt_createInstance() -> void *"},
	 { "ScXMLHistoryElt_initClass", _wrap_ScXMLHistoryElt_initClass, METH_NOARGS, "ScXMLHistoryElt_initClass()"},
	 { "ScXMLHistoryElt_cleanClass", _wrap_ScXMLHistoryElt_cleanClass, METH_NOARGS, "ScXMLHistoryElt_cleanClass()"},
	 { "new_ScXMLHistoryElt", _wrap_new_ScXMLHistoryElt, METH_NOARGS, "new_ScXMLHistoryElt() -> ScXMLHistoryElt"},
	 { "delete_ScXMLHistoryElt", _wrap_delete_ScXMLHistoryElt, METH_O, "delete_ScXMLHistoryElt(ScXMLHistoryElt self)"},
	 { "ScXMLHistoryElt_setIdAttribute", _wrap_ScXMLHistoryElt_setIdAttribute, METH_VARARGS, "ScXMLHistoryElt_setIdAttribute(ScXMLHistoryElt self, char const * id)"},
	 { "ScXMLHistoryElt_getIdAttribute", _wrap_ScXMLHistoryElt_getIdAttribute, METH_O, "ScXMLHistoryElt_getIdAttribute(ScXMLHistoryElt self) -> char const *"},
	 { "ScXMLHistoryElt_setTypeAttribute", _wrap_ScXMLHistoryElt_setTypeAttribute, METH_VARARGS, "ScXMLHistoryElt_setTypeAttribute(ScXMLHistoryElt self, char const * type)"},
	 { "ScXMLHistoryElt_getTypeAttribute", _wrap_ScXMLHistoryElt_getTypeAttribute, METH_O, "ScXMLHistoryElt_getTypeAttribute(ScXMLHistoryElt self) -> char const *"},
	 { "ScXMLHistoryElt_handleXMLAttributes", _wrap_ScXMLHistoryElt_handleXMLAttributes, METH_O, "ScXMLHistoryElt_handleXMLAttributes(ScXMLHistoryElt self) -> SbBool"},
	 { "ScXMLHistoryElt_copyContents", _wrap_ScXMLHistoryElt_copyContents, METH_VARARGS, "ScXMLHistoryElt_copyContents(ScXMLHistoryElt self, ScXMLElt rhs)"},
	 { "ScXMLHistoryElt_search", _wrap_ScXMLHistoryElt_search, METH_VARARGS, "ScXMLHistoryElt_search(ScXMLHistoryElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLHistoryElt_setTransition", _wrap_ScXMLHistoryElt_setTransition, METH_VARARGS, "ScXMLHistoryElt_setTransition(ScXMLHistoryElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLHistoryElt_getTransition", _wrap_ScXMLHistoryElt_getTransition, METH_O, "ScXMLHistoryElt_getTransition(ScXMLHistoryElt self) -> ScXMLTransitionElt"},
	 { "ScXMLHistoryElt_swigregister", ScXMLHistoryElt_swigregister, METH_O, NULL},
	 { "ScXMLHistoryElt_swiginit", ScXMLHistoryElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLIfElt_getElementReader", _wrap_ScXMLIfElt_getElementReader, METH_NOARGS, "ScXMLIfElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLIfElt_getClassTypeId", _wrap_ScXMLIfElt_getClassTypeId, METH_NOARGS, "ScXMLIfElt_getClassTypeId() -> SoType"},
	 { "ScXMLIfElt_getTypeId", _wrap_ScXMLIfElt_getTypeId, METH_O, "ScXMLIfElt_getTypeId(ScXMLIfElt self) -> SoType"},
	 { "ScXMLIfElt_createInstance", _wrap_ScXMLIfElt_createInstance, METH_NOARGS, "ScXMLIfElt_createInstance() -> void *"},
	 { "ScXMLIfElt_initClass", _wrap_ScXMLIfElt_initClass, METH_NOARGS, "ScXMLIfElt_initClass()"},
	 { "ScXMLIfElt_cleanClass", _wrap_ScXMLIfElt_cleanClass, METH_NOARGS, "ScXMLIfElt_cleanClass()"},
	 { "new_ScXMLIfElt", _wrap_new_ScXMLIfElt, METH_NOARGS, "new_ScXMLIfElt() -> ScXMLIfElt"},
	 { "delete_ScXMLIfElt", _wrap_delete_ScXMLIfElt, METH_O, "delete_ScXMLIfElt(ScXMLIfElt self)"},
	 { "ScXMLIfElt_setCondAttribute", _wrap_ScXMLIfElt_setCondAttribute, METH_VARARGS, "ScXMLIfElt_setCondAttribute(ScXMLIfElt self, char const * cond)"},
	 { "ScXMLIfElt_getCondAttribute", _wrap_ScXMLIfElt_getCondAttribute, METH_O, "ScXMLIfElt_getCondAttribute(ScXMLIfElt self) -> char const *"},
	 { "ScXMLIfElt_handleXMLAttributes", _wrap_ScXMLIfElt_handleXMLAttributes, METH_O, "ScXMLIfElt_handleXMLAttributes(ScXMLIfElt self) -> SbBool"},
	 { "ScXMLIfElt_copyContents", _wrap_ScXMLIfElt_copyContents, METH_VARARGS, "ScXMLIfElt_copyContents(ScXMLIfElt self, ScXMLElt rhs)"},
	 { "ScXMLIfElt_search", _wrap_ScXMLIfElt_search, METH_VARARGS, "ScXMLIfElt_search(ScXMLIfElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLIfElt_getNumElseIfs", _wrap_ScXMLIfElt_getNumElseIfs, METH_O, "ScXMLIfElt_getNumElseIfs(ScXMLIfElt self) -> int"},
	 { "ScXMLIfElt_getElseIf", _wrap_ScXMLIfElt_getElseIf, METH_VARARGS, "ScXMLIfElt_getElseIf(ScXMLIfElt self, int idx) -> ScXMLElseIfElt"},
	 { "ScXMLIfElt_addElseIf", _wrap_ScXMLIfElt_addElseIf, METH_VARARGS, "ScXMLIfElt_addElseIf(ScXMLIfElt self, ScXMLElseIfElt elseif)"},
	 { "ScXMLIfElt_removeElseIf", _wrap_ScXMLIfElt_removeElseIf, METH_VARARGS, "ScXMLIfElt_removeElseIf(ScXMLIfElt self, ScXMLElseIfElt elseif)"},
	 { "ScXMLIfElt_clearAllElseIfs", _wrap_ScXMLIfElt_clearAllElseIfs, METH_O, "ScXMLIfElt_clearAllElseIfs(ScXMLIfElt self)"},
	 { "ScXMLIfElt_setElse", _wrap_ScXMLIfElt_setElse, METH_VARARGS, "ScXMLIfElt_setElse(ScXMLIfElt self, ScXMLElseElt elseelt)"},
	 { "ScXMLIfElt_getElse", _wrap_ScXMLIfElt_getElse, METH_O, "ScXMLIfElt_getElse(ScXMLIfElt self) -> ScXMLElseElt"},
	 { "ScXMLIfElt_getNumExecutables", _wrap_ScXMLIfElt_getNumExecutables, METH_VARARGS, "ScXMLIfElt_getNumExecutables(ScXMLIfElt self, ScXMLExecutableElt conditional) -> int"},
	 { "ScXMLIfElt_getExecutable", _wrap_ScXMLIfElt_getExecutable, METH_VARARGS, "ScXMLIfElt_getExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, int idx) -> ScXMLExecutableElt"},
	 { "ScXMLIfElt_addExecutable", _wrap_ScXMLIfElt_addExecutable, METH_VARARGS, "ScXMLIfElt_addExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, ScXMLExecutableElt executable)"},
	 { "ScXMLIfElt_removeExecutable", _wrap_ScXMLIfElt_removeExecutable, METH_VARARGS, "ScXMLIfElt_removeExecutable(ScXMLIfElt self, ScXMLExecutableElt conditional, ScXMLExecutableElt executable)"},
	 { "ScXMLIfElt_clearAllExecutables", _wrap_ScXMLIfElt_clearAllExecutables, METH_VARARGS, "ScXMLIfElt_clearAllExecutables(ScXMLIfElt self, ScXMLExecutableElt conditional)"},
	 { "ScXMLIfElt_execute", _wrap_ScXMLIfElt_execute, METH_VARARGS, "ScXMLIfElt_execute(ScXMLIfElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLIfElt_swigregister", ScXMLIfElt_swigregister, METH_O, NULL},
	 { "ScXMLIfElt_swiginit", ScXMLIfElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLInitialElt_getElementReader", _wrap_ScXMLInitialElt_getElementReader, METH_NOARGS, "ScXMLInitialElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLInitialElt_getClassTypeId", _wrap_ScXMLInitialElt_getClassTypeId, METH_NOARGS, "ScXMLInitialElt_getClassTypeId() -> SoType"},
	 { "ScXMLInitialElt_getTypeId", _wrap_ScXMLInitialElt_getTypeId, METH_O, "ScXMLInitialElt_getTypeId(ScXMLInitialElt self) -> SoType"},
	 { "ScXMLInitialElt_createInstance", _wrap_ScXMLInitialElt_createInstance, METH_NOARGS, "ScXMLInitialElt_createInstance() -> void *"},
	 { "ScXMLInitialElt_initClass", _wrap_ScXMLInitialElt_initClass, METH_NOARGS, "ScXMLInitialElt_initClass()"},
	 { "ScXMLInitialElt_cleanClass", _wrap_ScXMLInitialElt_cleanClass, METH_NOARGS, "ScXMLInitialElt_cleanClass()"},
	 { "new_ScXMLInitialElt", _wrap_new_ScXMLInitialElt, METH_NOARGS, "new_ScXMLInitialElt() -> ScXMLInitialElt"},
	 { "delete_ScXMLInitialElt", _wrap_delete_ScXMLInitialElt, METH_O, "delete_ScXMLInitialElt(ScXMLInitialElt self)"},
	 { "ScXMLInitialElt_copyContents", _wrap_ScXMLInitialElt_copyContents, METH_VARARGS, "ScXMLInitialElt_copyContents(ScXMLInitialElt self, ScXMLElt rhs)"},
	 { "ScXMLInitialElt_search", _wrap_ScXMLInitialElt_search, METH_VARARGS, "ScXMLInitialElt_search(ScXMLInitialElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLInitialElt_setTransition", _wrap_ScXMLInitialElt_setTransition, METH_VARARGS, "ScXMLInitialElt_setTransition(ScXMLInitialElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLInitialElt_getTransition", _wrap_ScXMLInitialElt_getTransition, METH_O, "ScXMLInitialElt_getTransition(ScXMLInitialElt self) -> ScXMLTransitionElt"},
	 { "ScXMLInitialElt_swigregister", ScXMLInitialElt_swigregister, METH_O, NULL},
	 { "ScXMLInitialElt_swiginit", ScXMLInitialElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLInvokeElt_getElementReader", _wrap_ScXMLInvokeElt_getElementReader, METH_NOARGS, "ScXMLInvokeElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLInvokeElt_getClassTypeId", _wrap_ScXMLInvokeElt_getClassTypeId, METH_NOARGS, "ScXMLInvokeElt_getClassTypeId() -> SoType"},
	 { "ScXMLInvokeElt_getTypeId", _wrap_ScXMLInvokeElt_getTypeId, METH_O, "ScXMLInvokeElt_getTypeId(ScXMLInvokeElt self) -> SoType"},
	 { "ScXMLInvokeElt_createInstance", _wrap_ScXMLInvokeElt_createInstance, METH_NOARGS, "ScXMLInvokeElt_createInstance() -> void *"},
	 { "ScXMLInvokeElt_initClass", _wrap_ScXMLInvokeElt_initClass, METH_NOARGS, "ScXMLInvokeElt_initClass()"},
	 { "ScXMLInvokeElt_cleanClass", _wrap_ScXMLInvokeElt_cleanClass, METH_NOARGS, "ScXMLInvokeElt_cleanClass()"},
	 { "new_ScXMLInvokeElt", _wrap_new_ScXMLInvokeElt, METH_NOARGS, "new_ScXMLInvokeElt() -> ScXMLInvokeElt"},
	 { "delete_ScXMLInvokeElt", _wrap_delete_ScXMLInvokeElt, METH_O, "delete_ScXMLInvokeElt(ScXMLInvokeElt self)"},
	 { "ScXMLInvokeElt_setTargetTypeAttribute", _wrap_ScXMLInvokeElt_setTargetTypeAttribute, METH_VARARGS, "ScXMLInvokeElt_setTargetTypeAttribute(ScXMLInvokeElt self, char const * id)"},
	 { "ScXMLInvokeElt_getTargetTypeAttribute", _wrap_ScXMLInvokeElt_getTargetTypeAttribute, METH_O, "ScXMLInvokeElt_getTargetTypeAttribute(ScXMLInvokeElt self) -> char const *"},
	 { "ScXMLInvokeElt_setSrcAttribute", _wrap_ScXMLInvokeElt_setSrcAttribute, METH_VARARGS, "ScXMLInvokeElt_setSrcAttribute(ScXMLInvokeElt self, char const * id)"},
	 { "ScXMLInvokeElt_getSrcAttribute", _wrap_ScXMLInvokeElt_getSrcAttribute, METH_O, "ScXMLInvokeElt_getSrcAttribute(ScXMLInvokeElt self) -> char const *"},
	 { "ScXMLInvokeElt_setSrcExprAttribute", _wrap_ScXMLInvokeElt_setSrcExprAttribute, METH_VARARGS, "ScXMLInvokeElt_setSrcExprAttribute(ScXMLInvokeElt self, char const * id)"},
	 { "ScXMLInvokeElt_getSrcExprAttribute", _wrap_ScXMLInvokeElt_getSrcExprAttribute, METH_O, "ScXMLInvokeElt_getSrcExprAttribute(ScXMLInvokeElt self) -> char const *"},
	 { "ScXMLInvokeElt_handleXMLAttributes", _wrap_ScXMLInvokeElt_handleXMLAttributes, METH_O, "ScXMLInvokeElt_handleXMLAttributes(ScXMLInvokeElt self) -> SbBool"},
	 { "ScXMLInvokeElt_copyContents", _wrap_ScXMLInvokeElt_copyContents, METH_VARARGS, "ScXMLInvokeElt_copyContents(ScXMLInvokeElt self, ScXMLElt rhs)"},
	 { "ScXMLInvokeElt_search", _wrap_ScXMLInvokeElt_search, METH_VARARGS, "ScXMLInvokeElt_search(ScXMLInvokeElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLInvokeElt_getNumParams", _wrap_ScXMLInvokeElt_getNumParams, METH_O, "ScXMLInvokeElt_getNumParams(ScXMLInvokeElt self) -> int"},
	 { "ScXMLInvokeElt_getParam", _wrap_ScXMLInvokeElt_getParam, METH_VARARGS, "ScXMLInvokeElt_getParam(ScXMLInvokeElt self, int idx) -> ScXMLParamElt"},
	 { "ScXMLInvokeElt_addParam", _wrap_ScXMLInvokeElt_addParam, METH_VARARGS, "ScXMLInvokeElt_addParam(ScXMLInvokeElt self, ScXMLParamElt param)"},
	 { "ScXMLInvokeElt_removeParam", _wrap_ScXMLInvokeElt_removeParam, METH_VARARGS, "ScXMLInvokeElt_removeParam(ScXMLInvokeElt self, ScXMLParamElt param)"},
	 { "ScXMLInvokeElt_clearAllParams", _wrap_ScXMLInvokeElt_clearAllParams, METH_O, "ScXMLInvokeElt_clearAllParams(ScXMLInvokeElt self)"},
	 { "ScXMLInvokeElt_setFinalize", _wrap_ScXMLInvokeElt_setFinalize, METH_VARARGS, "ScXMLInvokeElt_setFinalize(ScXMLInvokeElt self, ScXMLFinalizeElt finalize)"},
	 { "ScXMLInvokeElt_getFinalize", _wrap_ScXMLInvokeElt_getFinalize, METH_O, "ScXMLInvokeElt_getFinalize(ScXMLInvokeElt self) -> ScXMLFinalizeElt"},
	 { "ScXMLInvokeElt_setContent", _wrap_ScXMLInvokeElt_setContent, METH_VARARGS, "ScXMLInvokeElt_setContent(ScXMLInvokeElt self, ScXMLContentElt content)"},
	 { "ScXMLInvokeElt_getContent", _wrap_ScXMLInvokeElt_getContent, METH_O, "ScXMLInvokeElt_getContent(ScXMLInvokeElt self) -> ScXMLContentElt"},
	 { "ScXMLInvokeElt_swigregister", ScXMLInvokeElt_swigregister, METH_O, NULL},
	 { "ScXMLInvokeElt_swiginit", ScXMLInvokeElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLLogElt_getElementReader", _wrap_ScXMLLogElt_getElementReader, METH_NOARGS, "ScXMLLogElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLLogElt_getClassTypeId", _wrap_ScXMLLogElt_getClassTypeId, METH_NOARGS, "ScXMLLogElt_getClassTypeId() -> SoType"},
	 { "ScXMLLogElt_getTypeId", _wrap_ScXMLLogElt_getTypeId, METH_O, "ScXMLLogElt_getTypeId(ScXMLLogElt self) -> SoType"},
	 { "ScXMLLogElt_createInstance", _wrap_ScXMLLogElt_createInstance, METH_NOARGS, "ScXMLLogElt_createInstance() -> void *"},
	 { "ScXMLLogElt_initClass", _wrap_ScXMLLogElt_initClass, METH_NOARGS, "ScXMLLogElt_initClass()"},
	 { "ScXMLLogElt_cleanClass", _wrap_ScXMLLogElt_cleanClass, METH_NOARGS, "ScXMLLogElt_cleanClass()"},
	 { "new_ScXMLLogElt", _wrap_new_ScXMLLogElt, METH_NOARGS, "new_ScXMLLogElt() -> ScXMLLogElt"},
	 { "delete_ScXMLLogElt", _wrap_delete_ScXMLLogElt, METH_O, "delete_ScXMLLogElt(ScXMLLogElt self)"},
	 { "ScXMLLogElt_setLabelAttribute", _wrap_ScXMLLogElt_setLabelAttribute, METH_VARARGS, "ScXMLLogElt_setLabelAttribute(ScXMLLogElt self, char const * label)"},
	 { "ScXMLLogElt_getLabelAttribute", _wrap_ScXMLLogElt_getLabelAttribute, METH_O, "ScXMLLogElt_getLabelAttribute(ScXMLLogElt self) -> char const *"},
	 { "ScXMLLogElt_setExprAttribute", _wrap_ScXMLLogElt_setExprAttribute, METH_VARARGS, "ScXMLLogElt_setExprAttribute(ScXMLLogElt self, char const * expr)"},
	 { "ScXMLLogElt_getExprAttribute", _wrap_ScXMLLogElt_getExprAttribute, METH_O, "ScXMLLogElt_getExprAttribute(ScXMLLogElt self) -> char const *"},
	 { "ScXMLLogElt_setLevelAttribute", _wrap_ScXMLLogElt_setLevelAttribute, METH_VARARGS, "ScXMLLogElt_setLevelAttribute(ScXMLLogElt self, char const * level)"},
	 { "ScXMLLogElt_getLevelAttribute", _wrap_ScXMLLogElt_getLevelAttribute, METH_O, "ScXMLLogElt_getLevelAttribute(ScXMLLogElt self) -> char const *"},
	 { "ScXMLLogElt_handleXMLAttributes", _wrap_ScXMLLogElt_handleXMLAttributes, METH_O, "ScXMLLogElt_handleXMLAttributes(ScXMLLogElt self) -> SbBool"},
	 { "ScXMLLogElt_copyContents", _wrap_ScXMLLogElt_copyContents, METH_VARARGS, "ScXMLLogElt_copyContents(ScXMLLogElt self, ScXMLElt rhs)"},
	 { "ScXMLLogElt_search", _wrap_ScXMLLogElt_search, METH_VARARGS, "ScXMLLogElt_search(ScXMLLogElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLLogElt_execute", _wrap_ScXMLLogElt_execute, METH_VARARGS, "ScXMLLogElt_execute(ScXMLLogElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLLogElt_swigregister", ScXMLLogElt_swigregister, METH_O, NULL},
	 { "ScXMLLogElt_swiginit", ScXMLLogElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLMinimumEvaluator_getClassTypeId", _wrap_ScXMLMinimumEvaluator_getClassTypeId, METH_NOARGS, "ScXMLMinimumEvaluator_getClassTypeId() -> SoType"},
	 { "ScXMLMinimumEvaluator_getTypeId", _wrap_ScXMLMinimumEvaluator_getTypeId, METH_O, "ScXMLMinimumEvaluator_getTypeId(ScXMLMinimumEvaluator self) -> SoType"},
	 { "ScXMLMinimumEvaluator_createInstance", _wrap_ScXMLMinimumEvaluator_createInstance, METH_NOARGS, "ScXMLMinimumEvaluator_createInstance() -> void *"},
	 { "ScXMLMinimumEvaluator_initClass", _wrap_ScXMLMinimumEvaluator_initClass, METH_NOARGS, "ScXMLMinimumEvaluator_initClass()"},
	 { "ScXMLMinimumEvaluator_cleanClass", _wrap_ScXMLMinimumEvaluator_cleanClass, METH_NOARGS, "ScXMLMinimumEvaluator_cleanClass()"},
	 { "new_ScXMLMinimumEvaluator", _wrap_new_ScXMLMinimumEvaluator, METH_NOARGS, "new_ScXMLMinimumEvaluator() -> ScXMLMinimumEvaluator"},
	 { "delete_ScXMLMinimumEvaluator", _wrap_delete_ScXMLMinimumEvaluator, METH_O, "delete_ScXMLMinimumEvaluator(ScXMLMinimumEvaluator self)"},
	 { "ScXMLMinimumEvaluator_setStateMachine", _wrap_ScXMLMinimumEvaluator_setStateMachine, METH_VARARGS, "ScXMLMinimumEvaluator_setStateMachine(ScXMLMinimumEvaluator self, ScXMLStateMachine arg2)"},
	 { "ScXMLMinimumEvaluator_evaluate", _wrap_ScXMLMinimumEvaluator_evaluate, METH_VARARGS, "ScXMLMinimumEvaluator_evaluate(ScXMLMinimumEvaluator self, char const * expression) -> ScXMLDataObj"},
	 { "ScXMLMinimumEvaluator_setAtLocation", _wrap_ScXMLMinimumEvaluator_setAtLocation, METH_VARARGS, "ScXMLMinimumEvaluator_setAtLocation(ScXMLMinimumEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"},
	 { "ScXMLMinimumEvaluator_locate", _wrap_ScXMLMinimumEvaluator_locate, METH_VARARGS, "ScXMLMinimumEvaluator_locate(ScXMLMinimumEvaluator self, char const * location) -> ScXMLDataObj"},
	 { "ScXMLMinimumEvaluator_clearTemporaryVariables", _wrap_ScXMLMinimumEvaluator_clearTemporaryVariables, METH_O, "ScXMLMinimumEvaluator_clearTemporaryVariables(ScXMLMinimumEvaluator self)"},
	 { "ScXMLMinimumEvaluator_swigregister", ScXMLMinimumEvaluator_swigregister, METH_O, NULL},
	 { "ScXMLMinimumEvaluator_swiginit", ScXMLMinimumEvaluator_swiginit, METH_VARARGS, NULL},
	 { "ScXMLMinimumExprDataObj_getClassTypeId", _wrap_ScXMLMinimumExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLMinimumExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLMinimumExprDataObj_getTypeId", _wrap_ScXMLMinimumExprDataObj_getTypeId, METH_O, "ScXMLMinimumExprDataObj_getTypeId(ScXMLMinimumExprDataObj self) -> SoType"},
	 { "ScXMLMinimumExprDataObj_initClass", _wrap_ScXMLMinimumExprDataObj_initClass, METH_NOARGS, "ScXMLMinimumExprDataObj_initClass()"},
	 { "ScXMLMinimumExprDataObj_cleanClass", _wrap_ScXMLMinimumExprDataObj_cleanClass, METH_NOARGS, "ScXMLMinimumExprDataObj_cleanClass()"},
	 { "delete_ScXMLMinimumExprDataObj", _wrap_delete_ScXMLMinimumExprDataObj, METH_O, "delete_ScXMLMinimumExprDataObj(ScXMLMinimumExprDataObj self)"},
	 { "ScXMLMinimumExprDataObj_swigregister", ScXMLMinimumExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLInExprDataObj_getClassTypeId", _wrap_ScXMLInExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLInExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLInExprDataObj_getTypeId", _wrap_ScXMLInExprDataObj_getTypeId, METH_O, "ScXMLInExprDataObj_getTypeId(ScXMLInExprDataObj self) -> SoType"},
	 { "ScXMLInExprDataObj_createInstance", _wrap_ScXMLInExprDataObj_createInstance, METH_NOARGS, "ScXMLInExprDataObj_createInstance() -> void *"},
	 { "ScXMLInExprDataObj_initClass", _wrap_ScXMLInExprDataObj_initClass, METH_NOARGS, "ScXMLInExprDataObj_initClass()"},
	 { "ScXMLInExprDataObj_cleanClass", _wrap_ScXMLInExprDataObj_cleanClass, METH_NOARGS, "ScXMLInExprDataObj_cleanClass()"},
	 { "ScXMLInExprDataObj_createFor", _wrap_ScXMLInExprDataObj_createFor, METH_O, "ScXMLInExprDataObj_createFor(char const * stateid) -> ScXMLDataObj"},
	 { "new_ScXMLInExprDataObj", _wrap_new_ScXMLInExprDataObj, METH_VARARGS, "\n"
		"ScXMLInExprDataObj()\n"
		"new_ScXMLInExprDataObj(char const * stateid) -> ScXMLInExprDataObj\n"
		""},
	 { "delete_ScXMLInExprDataObj", _wrap_delete_ScXMLInExprDataObj, METH_O, "delete_ScXMLInExprDataObj(ScXMLInExprDataObj self)"},
	 { "ScXMLInExprDataObj_setStateId", _wrap_ScXMLInExprDataObj_setStateId, METH_VARARGS, "ScXMLInExprDataObj_setStateId(ScXMLInExprDataObj self, char const * stateid)"},
	 { "ScXMLInExprDataObj_getStateId", _wrap_ScXMLInExprDataObj_getStateId, METH_O, "ScXMLInExprDataObj_getStateId(ScXMLInExprDataObj self) -> char const *"},
	 { "ScXMLInExprDataObj_swigregister", ScXMLInExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLInExprDataObj_swiginit", ScXMLInExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLAppendOpExprDataObj_getClassTypeId", _wrap_ScXMLAppendOpExprDataObj_getClassTypeId, METH_NOARGS, "ScXMLAppendOpExprDataObj_getClassTypeId() -> SoType"},
	 { "ScXMLAppendOpExprDataObj_getTypeId", _wrap_ScXMLAppendOpExprDataObj_getTypeId, METH_O, "ScXMLAppendOpExprDataObj_getTypeId(ScXMLAppendOpExprDataObj self) -> SoType"},
	 { "ScXMLAppendOpExprDataObj_createInstance", _wrap_ScXMLAppendOpExprDataObj_createInstance, METH_NOARGS, "ScXMLAppendOpExprDataObj_createInstance() -> void *"},
	 { "ScXMLAppendOpExprDataObj_initClass", _wrap_ScXMLAppendOpExprDataObj_initClass, METH_NOARGS, "ScXMLAppendOpExprDataObj_initClass()"},
	 { "ScXMLAppendOpExprDataObj_cleanClass", _wrap_ScXMLAppendOpExprDataObj_cleanClass, METH_NOARGS, "ScXMLAppendOpExprDataObj_cleanClass()"},
	 { "ScXMLAppendOpExprDataObj_createFor", _wrap_ScXMLAppendOpExprDataObj_createFor, METH_VARARGS, "ScXMLAppendOpExprDataObj_createFor(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLDataObj"},
	 { "new_ScXMLAppendOpExprDataObj", _wrap_new_ScXMLAppendOpExprDataObj, METH_VARARGS, "\n"
		"ScXMLAppendOpExprDataObj()\n"
		"new_ScXMLAppendOpExprDataObj(ScXMLDataObj lhs, ScXMLDataObj rhs) -> ScXMLAppendOpExprDataObj\n"
		""},
	 { "delete_ScXMLAppendOpExprDataObj", _wrap_delete_ScXMLAppendOpExprDataObj, METH_O, "delete_ScXMLAppendOpExprDataObj(ScXMLAppendOpExprDataObj self)"},
	 { "ScXMLAppendOpExprDataObj_setLHS", _wrap_ScXMLAppendOpExprDataObj_setLHS, METH_VARARGS, "ScXMLAppendOpExprDataObj_setLHS(ScXMLAppendOpExprDataObj self, ScXMLDataObj lhs)"},
	 { "ScXMLAppendOpExprDataObj_getLHS", _wrap_ScXMLAppendOpExprDataObj_getLHS, METH_O, "ScXMLAppendOpExprDataObj_getLHS(ScXMLAppendOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAppendOpExprDataObj_setRHS", _wrap_ScXMLAppendOpExprDataObj_setRHS, METH_VARARGS, "ScXMLAppendOpExprDataObj_setRHS(ScXMLAppendOpExprDataObj self, ScXMLDataObj rhs)"},
	 { "ScXMLAppendOpExprDataObj_getRHS", _wrap_ScXMLAppendOpExprDataObj_getRHS, METH_O, "ScXMLAppendOpExprDataObj_getRHS(ScXMLAppendOpExprDataObj self) -> ScXMLDataObj"},
	 { "ScXMLAppendOpExprDataObj_swigregister", ScXMLAppendOpExprDataObj_swigregister, METH_O, NULL},
	 { "ScXMLAppendOpExprDataObj_swiginit", ScXMLAppendOpExprDataObj_swiginit, METH_VARARGS, NULL},
	 { "ScXMLOnEntryElt_getElementReader", _wrap_ScXMLOnEntryElt_getElementReader, METH_NOARGS, "ScXMLOnEntryElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLOnEntryElt_getClassTypeId", _wrap_ScXMLOnEntryElt_getClassTypeId, METH_NOARGS, "ScXMLOnEntryElt_getClassTypeId() -> SoType"},
	 { "ScXMLOnEntryElt_getTypeId", _wrap_ScXMLOnEntryElt_getTypeId, METH_O, "ScXMLOnEntryElt_getTypeId(ScXMLOnEntryElt self) -> SoType"},
	 { "ScXMLOnEntryElt_createInstance", _wrap_ScXMLOnEntryElt_createInstance, METH_NOARGS, "ScXMLOnEntryElt_createInstance() -> void *"},
	 { "ScXMLOnEntryElt_initClass", _wrap_ScXMLOnEntryElt_initClass, METH_NOARGS, "ScXMLOnEntryElt_initClass()"},
	 { "ScXMLOnEntryElt_cleanClass", _wrap_ScXMLOnEntryElt_cleanClass, METH_NOARGS, "ScXMLOnEntryElt_cleanClass()"},
	 { "new_ScXMLOnEntryElt", _wrap_new_ScXMLOnEntryElt, METH_NOARGS, "new_ScXMLOnEntryElt() -> ScXMLOnEntryElt"},
	 { "delete_ScXMLOnEntryElt", _wrap_delete_ScXMLOnEntryElt, METH_O, "delete_ScXMLOnEntryElt(ScXMLOnEntryElt self)"},
	 { "ScXMLOnEntryElt_getNumExecutables", _wrap_ScXMLOnEntryElt_getNumExecutables, METH_O, "ScXMLOnEntryElt_getNumExecutables(ScXMLOnEntryElt self) -> int"},
	 { "ScXMLOnEntryElt_getExecutable", _wrap_ScXMLOnEntryElt_getExecutable, METH_VARARGS, "ScXMLOnEntryElt_getExecutable(ScXMLOnEntryElt self, int idx) -> ScXMLExecutableElt"},
	 { "ScXMLOnEntryElt_addExecutable", _wrap_ScXMLOnEntryElt_addExecutable, METH_VARARGS, "ScXMLOnEntryElt_addExecutable(ScXMLOnEntryElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLOnEntryElt_removeExecutable", _wrap_ScXMLOnEntryElt_removeExecutable, METH_VARARGS, "ScXMLOnEntryElt_removeExecutable(ScXMLOnEntryElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLOnEntryElt_clearAllExecutables", _wrap_ScXMLOnEntryElt_clearAllExecutables, METH_O, "ScXMLOnEntryElt_clearAllExecutables(ScXMLOnEntryElt self)"},
	 { "ScXMLOnEntryElt_copyContents", _wrap_ScXMLOnEntryElt_copyContents, METH_VARARGS, "ScXMLOnEntryElt_copyContents(ScXMLOnEntryElt self, ScXMLElt rhs)"},
	 { "ScXMLOnEntryElt_search", _wrap_ScXMLOnEntryElt_search, METH_VARARGS, "ScXMLOnEntryElt_search(ScXMLOnEntryElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLOnEntryElt_execute", _wrap_ScXMLOnEntryElt_execute, METH_VARARGS, "ScXMLOnEntryElt_execute(ScXMLOnEntryElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLOnEntryElt_swigregister", ScXMLOnEntryElt_swigregister, METH_O, NULL},
	 { "ScXMLOnEntryElt_swiginit", ScXMLOnEntryElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLOnExitElt_getElementReader", _wrap_ScXMLOnExitElt_getElementReader, METH_NOARGS, "ScXMLOnExitElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLOnExitElt_getClassTypeId", _wrap_ScXMLOnExitElt_getClassTypeId, METH_NOARGS, "ScXMLOnExitElt_getClassTypeId() -> SoType"},
	 { "ScXMLOnExitElt_getTypeId", _wrap_ScXMLOnExitElt_getTypeId, METH_O, "ScXMLOnExitElt_getTypeId(ScXMLOnExitElt self) -> SoType"},
	 { "ScXMLOnExitElt_createInstance", _wrap_ScXMLOnExitElt_createInstance, METH_NOARGS, "ScXMLOnExitElt_createInstance() -> void *"},
	 { "ScXMLOnExitElt_initClass", _wrap_ScXMLOnExitElt_initClass, METH_NOARGS, "ScXMLOnExitElt_initClass()"},
	 { "ScXMLOnExitElt_cleanClass", _wrap_ScXMLOnExitElt_cleanClass, METH_NOARGS, "ScXMLOnExitElt_cleanClass()"},
	 { "new_ScXMLOnExitElt", _wrap_new_ScXMLOnExitElt, METH_NOARGS, "new_ScXMLOnExitElt() -> ScXMLOnExitElt"},
	 { "delete_ScXMLOnExitElt", _wrap_delete_ScXMLOnExitElt, METH_O, "delete_ScXMLOnExitElt(ScXMLOnExitElt self)"},
	 { "ScXMLOnExitElt_getNumExecutables", _wrap_ScXMLOnExitElt_getNumExecutables, METH_O, "ScXMLOnExitElt_getNumExecutables(ScXMLOnExitElt self) -> int"},
	 { "ScXMLOnExitElt_getExecutable", _wrap_ScXMLOnExitElt_getExecutable, METH_VARARGS, "ScXMLOnExitElt_getExecutable(ScXMLOnExitElt self, int idx) -> ScXMLExecutableElt"},
	 { "ScXMLOnExitElt_addExecutable", _wrap_ScXMLOnExitElt_addExecutable, METH_VARARGS, "ScXMLOnExitElt_addExecutable(ScXMLOnExitElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLOnExitElt_removeExecutable", _wrap_ScXMLOnExitElt_removeExecutable, METH_VARARGS, "ScXMLOnExitElt_removeExecutable(ScXMLOnExitElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLOnExitElt_clearAllExecutables", _wrap_ScXMLOnExitElt_clearAllExecutables, METH_O, "ScXMLOnExitElt_clearAllExecutables(ScXMLOnExitElt self)"},
	 { "ScXMLOnExitElt_copyContents", _wrap_ScXMLOnExitElt_copyContents, METH_VARARGS, "ScXMLOnExitElt_copyContents(ScXMLOnExitElt self, ScXMLElt rhs)"},
	 { "ScXMLOnExitElt_search", _wrap_ScXMLOnExitElt_search, METH_VARARGS, "ScXMLOnExitElt_search(ScXMLOnExitElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLOnExitElt_execute", _wrap_ScXMLOnExitElt_execute, METH_VARARGS, "ScXMLOnExitElt_execute(ScXMLOnExitElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLOnExitElt_swigregister", ScXMLOnExitElt_swigregister, METH_O, NULL},
	 { "ScXMLOnExitElt_swiginit", ScXMLOnExitElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLParallelElt_getElementReader", _wrap_ScXMLParallelElt_getElementReader, METH_NOARGS, "ScXMLParallelElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLParallelElt_getClassTypeId", _wrap_ScXMLParallelElt_getClassTypeId, METH_NOARGS, "ScXMLParallelElt_getClassTypeId() -> SoType"},
	 { "ScXMLParallelElt_getTypeId", _wrap_ScXMLParallelElt_getTypeId, METH_O, "ScXMLParallelElt_getTypeId(ScXMLParallelElt self) -> SoType"},
	 { "ScXMLParallelElt_createInstance", _wrap_ScXMLParallelElt_createInstance, METH_NOARGS, "ScXMLParallelElt_createInstance() -> void *"},
	 { "ScXMLParallelElt_initClass", _wrap_ScXMLParallelElt_initClass, METH_NOARGS, "ScXMLParallelElt_initClass()"},
	 { "ScXMLParallelElt_cleanClass", _wrap_ScXMLParallelElt_cleanClass, METH_NOARGS, "ScXMLParallelElt_cleanClass()"},
	 { "new_ScXMLParallelElt", _wrap_new_ScXMLParallelElt, METH_NOARGS, "new_ScXMLParallelElt() -> ScXMLParallelElt"},
	 { "delete_ScXMLParallelElt", _wrap_delete_ScXMLParallelElt, METH_O, "delete_ScXMLParallelElt(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_setSrcAttribute", _wrap_ScXMLParallelElt_setSrcAttribute, METH_VARARGS, "ScXMLParallelElt_setSrcAttribute(ScXMLParallelElt self, char const * src)"},
	 { "ScXMLParallelElt_getSrcAttribute", _wrap_ScXMLParallelElt_getSrcAttribute, METH_O, "ScXMLParallelElt_getSrcAttribute(ScXMLParallelElt self) -> char const *"},
	 { "ScXMLParallelElt_handleXMLAttributes", _wrap_ScXMLParallelElt_handleXMLAttributes, METH_O, "ScXMLParallelElt_handleXMLAttributes(ScXMLParallelElt self) -> SbBool"},
	 { "ScXMLParallelElt_copyContents", _wrap_ScXMLParallelElt_copyContents, METH_VARARGS, "ScXMLParallelElt_copyContents(ScXMLParallelElt self, ScXMLElt rhs)"},
	 { "ScXMLParallelElt_search", _wrap_ScXMLParallelElt_search, METH_VARARGS, "ScXMLParallelElt_search(ScXMLParallelElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLParallelElt_setOnEntry", _wrap_ScXMLParallelElt_setOnEntry, METH_VARARGS, "ScXMLParallelElt_setOnEntry(ScXMLParallelElt self, ScXMLOnEntryElt onentry)"},
	 { "ScXMLParallelElt_getOnEntry", _wrap_ScXMLParallelElt_getOnEntry, METH_O, "ScXMLParallelElt_getOnEntry(ScXMLParallelElt self) -> ScXMLOnEntryElt"},
	 { "ScXMLParallelElt_setOnExit", _wrap_ScXMLParallelElt_setOnExit, METH_VARARGS, "ScXMLParallelElt_setOnExit(ScXMLParallelElt self, ScXMLOnExitElt onexit)"},
	 { "ScXMLParallelElt_getOnExit", _wrap_ScXMLParallelElt_getOnExit, METH_O, "ScXMLParallelElt_getOnExit(ScXMLParallelElt self) -> ScXMLOnExitElt"},
	 { "ScXMLParallelElt_getNumTransitions", _wrap_ScXMLParallelElt_getNumTransitions, METH_O, "ScXMLParallelElt_getNumTransitions(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getTransition", _wrap_ScXMLParallelElt_getTransition, METH_VARARGS, "ScXMLParallelElt_getTransition(ScXMLParallelElt self, int idx) -> ScXMLTransitionElt"},
	 { "ScXMLParallelElt_addTransition", _wrap_ScXMLParallelElt_addTransition, METH_VARARGS, "ScXMLParallelElt_addTransition(ScXMLParallelElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLParallelElt_removeTransition", _wrap_ScXMLParallelElt_removeTransition, METH_VARARGS, "ScXMLParallelElt_removeTransition(ScXMLParallelElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLParallelElt_clearAllTransitions", _wrap_ScXMLParallelElt_clearAllTransitions, METH_O, "ScXMLParallelElt_clearAllTransitions(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_setInitial", _wrap_ScXMLParallelElt_setInitial, METH_VARARGS, "ScXMLParallelElt_setInitial(ScXMLParallelElt self, ScXMLInitialElt initial)"},
	 { "ScXMLParallelElt_getInitial", _wrap_ScXMLParallelElt_getInitial, METH_O, "ScXMLParallelElt_getInitial(ScXMLParallelElt self) -> ScXMLInitialElt"},
	 { "ScXMLParallelElt_getNumStates", _wrap_ScXMLParallelElt_getNumStates, METH_O, "ScXMLParallelElt_getNumStates(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getState", _wrap_ScXMLParallelElt_getState, METH_VARARGS, "ScXMLParallelElt_getState(ScXMLParallelElt self, int idx) -> ScXMLStateElt"},
	 { "ScXMLParallelElt_addState", _wrap_ScXMLParallelElt_addState, METH_VARARGS, "ScXMLParallelElt_addState(ScXMLParallelElt self, ScXMLStateElt state)"},
	 { "ScXMLParallelElt_removeState", _wrap_ScXMLParallelElt_removeState, METH_VARARGS, "ScXMLParallelElt_removeState(ScXMLParallelElt self, ScXMLStateElt state)"},
	 { "ScXMLParallelElt_clearAllStates", _wrap_ScXMLParallelElt_clearAllStates, METH_O, "ScXMLParallelElt_clearAllStates(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_getNumParallels", _wrap_ScXMLParallelElt_getNumParallels, METH_O, "ScXMLParallelElt_getNumParallels(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getParallel", _wrap_ScXMLParallelElt_getParallel, METH_VARARGS, "ScXMLParallelElt_getParallel(ScXMLParallelElt self, int idx) -> ScXMLParallelElt"},
	 { "ScXMLParallelElt_addParallel", _wrap_ScXMLParallelElt_addParallel, METH_VARARGS, "ScXMLParallelElt_addParallel(ScXMLParallelElt self, ScXMLParallelElt state)"},
	 { "ScXMLParallelElt_removeParallel", _wrap_ScXMLParallelElt_removeParallel, METH_VARARGS, "ScXMLParallelElt_removeParallel(ScXMLParallelElt self, ScXMLParallelElt state)"},
	 { "ScXMLParallelElt_clearAllParallels", _wrap_ScXMLParallelElt_clearAllParallels, METH_O, "ScXMLParallelElt_clearAllParallels(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_getNumFinals", _wrap_ScXMLParallelElt_getNumFinals, METH_O, "ScXMLParallelElt_getNumFinals(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getFinal", _wrap_ScXMLParallelElt_getFinal, METH_VARARGS, "ScXMLParallelElt_getFinal(ScXMLParallelElt self, int idx) -> ScXMLFinalElt"},
	 { "ScXMLParallelElt_addFinal", _wrap_ScXMLParallelElt_addFinal, METH_VARARGS, "ScXMLParallelElt_addFinal(ScXMLParallelElt self, ScXMLFinalElt state)"},
	 { "ScXMLParallelElt_removeFinal", _wrap_ScXMLParallelElt_removeFinal, METH_VARARGS, "ScXMLParallelElt_removeFinal(ScXMLParallelElt self, ScXMLFinalElt state)"},
	 { "ScXMLParallelElt_clearAllFinals", _wrap_ScXMLParallelElt_clearAllFinals, METH_O, "ScXMLParallelElt_clearAllFinals(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_getNumHistories", _wrap_ScXMLParallelElt_getNumHistories, METH_O, "ScXMLParallelElt_getNumHistories(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getHistory", _wrap_ScXMLParallelElt_getHistory, METH_VARARGS, "ScXMLParallelElt_getHistory(ScXMLParallelElt self, int idx) -> ScXMLHistoryElt"},
	 { "ScXMLParallelElt_addHistory", _wrap_ScXMLParallelElt_addHistory, METH_VARARGS, "ScXMLParallelElt_addHistory(ScXMLParallelElt self, ScXMLHistoryElt history)"},
	 { "ScXMLParallelElt_removeHistory", _wrap_ScXMLParallelElt_removeHistory, METH_VARARGS, "ScXMLParallelElt_removeHistory(ScXMLParallelElt self, ScXMLHistoryElt history)"},
	 { "ScXMLParallelElt_clearAllHistories", _wrap_ScXMLParallelElt_clearAllHistories, METH_O, "ScXMLParallelElt_clearAllHistories(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_getNumAnchors", _wrap_ScXMLParallelElt_getNumAnchors, METH_O, "ScXMLParallelElt_getNumAnchors(ScXMLParallelElt self) -> int"},
	 { "ScXMLParallelElt_getAnchor", _wrap_ScXMLParallelElt_getAnchor, METH_VARARGS, "ScXMLParallelElt_getAnchor(ScXMLParallelElt self, int idx) -> ScXMLAnchorElt"},
	 { "ScXMLParallelElt_addAnchor", _wrap_ScXMLParallelElt_addAnchor, METH_VARARGS, "ScXMLParallelElt_addAnchor(ScXMLParallelElt self, ScXMLAnchorElt anchor)"},
	 { "ScXMLParallelElt_removeAnchor", _wrap_ScXMLParallelElt_removeAnchor, METH_VARARGS, "ScXMLParallelElt_removeAnchor(ScXMLParallelElt self, ScXMLAnchorElt anchor)"},
	 { "ScXMLParallelElt_clearAllAnchors", _wrap_ScXMLParallelElt_clearAllAnchors, METH_O, "ScXMLParallelElt_clearAllAnchors(ScXMLParallelElt self)"},
	 { "ScXMLParallelElt_setDataModel", _wrap_ScXMLParallelElt_setDataModel, METH_VARARGS, "ScXMLParallelElt_setDataModel(ScXMLParallelElt self, ScXMLDataModelElt datamodel)"},
	 { "ScXMLParallelElt_getDataModel", _wrap_ScXMLParallelElt_getDataModel, METH_O, "ScXMLParallelElt_getDataModel(ScXMLParallelElt self) -> ScXMLDataModelElt"},
	 { "ScXMLParallelElt_isAtomicState", _wrap_ScXMLParallelElt_isAtomicState, METH_O, "ScXMLParallelElt_isAtomicState(ScXMLParallelElt self) -> SbBool"},
	 { "ScXMLParallelElt_swigregister", ScXMLParallelElt_swigregister, METH_O, NULL},
	 { "ScXMLParallelElt_swiginit", ScXMLParallelElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLParamElt_getElementReader", _wrap_ScXMLParamElt_getElementReader, METH_NOARGS, "ScXMLParamElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLParamElt_getClassTypeId", _wrap_ScXMLParamElt_getClassTypeId, METH_NOARGS, "ScXMLParamElt_getClassTypeId() -> SoType"},
	 { "ScXMLParamElt_getTypeId", _wrap_ScXMLParamElt_getTypeId, METH_O, "ScXMLParamElt_getTypeId(ScXMLParamElt self) -> SoType"},
	 { "ScXMLParamElt_createInstance", _wrap_ScXMLParamElt_createInstance, METH_NOARGS, "ScXMLParamElt_createInstance() -> void *"},
	 { "ScXMLParamElt_initClass", _wrap_ScXMLParamElt_initClass, METH_NOARGS, "ScXMLParamElt_initClass()"},
	 { "ScXMLParamElt_cleanClass", _wrap_ScXMLParamElt_cleanClass, METH_NOARGS, "ScXMLParamElt_cleanClass()"},
	 { "new_ScXMLParamElt", _wrap_new_ScXMLParamElt, METH_NOARGS, "new_ScXMLParamElt() -> ScXMLParamElt"},
	 { "delete_ScXMLParamElt", _wrap_delete_ScXMLParamElt, METH_O, "delete_ScXMLParamElt(ScXMLParamElt self)"},
	 { "ScXMLParamElt_setNameAttribute", _wrap_ScXMLParamElt_setNameAttribute, METH_VARARGS, "ScXMLParamElt_setNameAttribute(ScXMLParamElt self, char const * name)"},
	 { "ScXMLParamElt_getNameAttribute", _wrap_ScXMLParamElt_getNameAttribute, METH_O, "ScXMLParamElt_getNameAttribute(ScXMLParamElt self) -> char const *"},
	 { "ScXMLParamElt_setExprAttribute", _wrap_ScXMLParamElt_setExprAttribute, METH_VARARGS, "ScXMLParamElt_setExprAttribute(ScXMLParamElt self, char const * expr)"},
	 { "ScXMLParamElt_getExprAttribute", _wrap_ScXMLParamElt_getExprAttribute, METH_O, "ScXMLParamElt_getExprAttribute(ScXMLParamElt self) -> char const *"},
	 { "ScXMLParamElt_handleXMLAttributes", _wrap_ScXMLParamElt_handleXMLAttributes, METH_O, "ScXMLParamElt_handleXMLAttributes(ScXMLParamElt self) -> SbBool"},
	 { "ScXMLParamElt_copyContents", _wrap_ScXMLParamElt_copyContents, METH_VARARGS, "ScXMLParamElt_copyContents(ScXMLParamElt self, ScXMLElt rhs)"},
	 { "ScXMLParamElt_search", _wrap_ScXMLParamElt_search, METH_VARARGS, "ScXMLParamElt_search(ScXMLParamElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLParamElt_swigregister", ScXMLParamElt_swigregister, METH_O, NULL},
	 { "ScXMLParamElt_swiginit", ScXMLParamElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLScriptElt_getElementReader", _wrap_ScXMLScriptElt_getElementReader, METH_NOARGS, "ScXMLScriptElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLScriptElt_getClassTypeId", _wrap_ScXMLScriptElt_getClassTypeId, METH_NOARGS, "ScXMLScriptElt_getClassTypeId() -> SoType"},
	 { "ScXMLScriptElt_getTypeId", _wrap_ScXMLScriptElt_getTypeId, METH_O, "ScXMLScriptElt_getTypeId(ScXMLScriptElt self) -> SoType"},
	 { "ScXMLScriptElt_createInstance", _wrap_ScXMLScriptElt_createInstance, METH_NOARGS, "ScXMLScriptElt_createInstance() -> void *"},
	 { "ScXMLScriptElt_initClass", _wrap_ScXMLScriptElt_initClass, METH_NOARGS, "ScXMLScriptElt_initClass()"},
	 { "ScXMLScriptElt_cleanClass", _wrap_ScXMLScriptElt_cleanClass, METH_NOARGS, "ScXMLScriptElt_cleanClass()"},
	 { "new_ScXMLScriptElt", _wrap_new_ScXMLScriptElt, METH_NOARGS, "new_ScXMLScriptElt() -> ScXMLScriptElt"},
	 { "delete_ScXMLScriptElt", _wrap_delete_ScXMLScriptElt, METH_O, "delete_ScXMLScriptElt(ScXMLScriptElt self)"},
	 { "ScXMLScriptElt_copyContents", _wrap_ScXMLScriptElt_copyContents, METH_VARARGS, "ScXMLScriptElt_copyContents(ScXMLScriptElt self, ScXMLElt rhs)"},
	 { "ScXMLScriptElt_execute", _wrap_ScXMLScriptElt_execute, METH_VARARGS, "ScXMLScriptElt_execute(ScXMLScriptElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLScriptElt_swigregister", ScXMLScriptElt_swigregister, METH_O, NULL},
	 { "ScXMLScriptElt_swiginit", ScXMLScriptElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLScxmlElt_getElementReader", _wrap_ScXMLScxmlElt_getElementReader, METH_NOARGS, "ScXMLScxmlElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLScxmlElt_getClassTypeId", _wrap_ScXMLScxmlElt_getClassTypeId, METH_NOARGS, "ScXMLScxmlElt_getClassTypeId() -> SoType"},
	 { "ScXMLScxmlElt_getTypeId", _wrap_ScXMLScxmlElt_getTypeId, METH_O, "ScXMLScxmlElt_getTypeId(ScXMLScxmlElt self) -> SoType"},
	 { "ScXMLScxmlElt_createInstance", _wrap_ScXMLScxmlElt_createInstance, METH_NOARGS, "ScXMLScxmlElt_createInstance() -> void *"},
	 { "ScXMLScxmlElt_initClass", _wrap_ScXMLScxmlElt_initClass, METH_NOARGS, "ScXMLScxmlElt_initClass()"},
	 { "ScXMLScxmlElt_cleanClass", _wrap_ScXMLScxmlElt_cleanClass, METH_NOARGS, "ScXMLScxmlElt_cleanClass()"},
	 { "new_ScXMLScxmlElt", _wrap_new_ScXMLScxmlElt, METH_NOARGS, "new_ScXMLScxmlElt() -> ScXMLScxmlElt"},
	 { "delete_ScXMLScxmlElt", _wrap_delete_ScXMLScxmlElt, METH_O, "delete_ScXMLScxmlElt(ScXMLScxmlElt self)"},
	 { "ScXMLScxmlElt_setIsReferenced", _wrap_ScXMLScxmlElt_setIsReferenced, METH_VARARGS, "ScXMLScxmlElt_setIsReferenced(ScXMLScxmlElt self, SbBool referenced)"},
	 { "ScXMLScxmlElt_isReferenced", _wrap_ScXMLScxmlElt_isReferenced, METH_O, "ScXMLScxmlElt_isReferenced(ScXMLScxmlElt self) -> SbBool"},
	 { "ScXMLScxmlElt_setInitialAttribute", _wrap_ScXMLScxmlElt_setInitialAttribute, METH_VARARGS, "ScXMLScxmlElt_setInitialAttribute(ScXMLScxmlElt self, char const * initial)"},
	 { "ScXMLScxmlElt_getInitialAttribute", _wrap_ScXMLScxmlElt_getInitialAttribute, METH_O, "ScXMLScxmlElt_getInitialAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_setNameAttribute", _wrap_ScXMLScxmlElt_setNameAttribute, METH_VARARGS, "ScXMLScxmlElt_setNameAttribute(ScXMLScxmlElt self, char const * name)"},
	 { "ScXMLScxmlElt_getNameAttribute", _wrap_ScXMLScxmlElt_getNameAttribute, METH_O, "ScXMLScxmlElt_getNameAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_setXMLNSAttribute", _wrap_ScXMLScxmlElt_setXMLNSAttribute, METH_VARARGS, "ScXMLScxmlElt_setXMLNSAttribute(ScXMLScxmlElt self, char const * xmlns)"},
	 { "ScXMLScxmlElt_getXMLNSAttribute", _wrap_ScXMLScxmlElt_getXMLNSAttribute, METH_O, "ScXMLScxmlElt_getXMLNSAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_setVersionAttribute", _wrap_ScXMLScxmlElt_setVersionAttribute, METH_VARARGS, "ScXMLScxmlElt_setVersionAttribute(ScXMLScxmlElt self, char const * version)"},
	 { "ScXMLScxmlElt_getVersionAttribute", _wrap_ScXMLScxmlElt_getVersionAttribute, METH_O, "ScXMLScxmlElt_getVersionAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_setProfileAttribute", _wrap_ScXMLScxmlElt_setProfileAttribute, METH_VARARGS, "ScXMLScxmlElt_setProfileAttribute(ScXMLScxmlElt self, char const * profile)"},
	 { "ScXMLScxmlElt_getProfileAttribute", _wrap_ScXMLScxmlElt_getProfileAttribute, METH_O, "ScXMLScxmlElt_getProfileAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_setExModeAttribute", _wrap_ScXMLScxmlElt_setExModeAttribute, METH_VARARGS, "ScXMLScxmlElt_setExModeAttribute(ScXMLScxmlElt self, char const * exmode)"},
	 { "ScXMLScxmlElt_getExModeAttribute", _wrap_ScXMLScxmlElt_getExModeAttribute, METH_O, "ScXMLScxmlElt_getExModeAttribute(ScXMLScxmlElt self) -> char const *"},
	 { "ScXMLScxmlElt_handleXMLAttributes", _wrap_ScXMLScxmlElt_handleXMLAttributes, METH_O, "ScXMLScxmlElt_handleXMLAttributes(ScXMLScxmlElt self) -> SbBool"},
	 { "ScXMLScxmlElt_copyContents", _wrap_ScXMLScxmlElt_copyContents, METH_VARARGS, "ScXMLScxmlElt_copyContents(ScXMLScxmlElt self, ScXMLElt rhs)"},
	 { "ScXMLScxmlElt_search", _wrap_ScXMLScxmlElt_search, METH_VARARGS, "ScXMLScxmlElt_search(ScXMLScxmlElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLScxmlElt_setInitial", _wrap_ScXMLScxmlElt_setInitial, METH_VARARGS, "ScXMLScxmlElt_setInitial(ScXMLScxmlElt self, ScXMLInitialElt initial)"},
	 { "ScXMLScxmlElt_getInitial", _wrap_ScXMLScxmlElt_getInitial, METH_O, "ScXMLScxmlElt_getInitial(ScXMLScxmlElt self) -> ScXMLInitialElt"},
	 { "ScXMLScxmlElt_getNumStates", _wrap_ScXMLScxmlElt_getNumStates, METH_O, "ScXMLScxmlElt_getNumStates(ScXMLScxmlElt self) -> int"},
	 { "ScXMLScxmlElt_getState", _wrap_ScXMLScxmlElt_getState, METH_VARARGS, "ScXMLScxmlElt_getState(ScXMLScxmlElt self, int idx) -> ScXMLStateElt"},
	 { "ScXMLScxmlElt_addState", _wrap_ScXMLScxmlElt_addState, METH_VARARGS, "ScXMLScxmlElt_addState(ScXMLScxmlElt self, ScXMLStateElt state)"},
	 { "ScXMLScxmlElt_removeState", _wrap_ScXMLScxmlElt_removeState, METH_VARARGS, "ScXMLScxmlElt_removeState(ScXMLScxmlElt self, ScXMLStateElt state)"},
	 { "ScXMLScxmlElt_clearAllStates", _wrap_ScXMLScxmlElt_clearAllStates, METH_O, "ScXMLScxmlElt_clearAllStates(ScXMLScxmlElt self)"},
	 { "ScXMLScxmlElt_getNumParallels", _wrap_ScXMLScxmlElt_getNumParallels, METH_O, "ScXMLScxmlElt_getNumParallels(ScXMLScxmlElt self) -> int"},
	 { "ScXMLScxmlElt_getParallel", _wrap_ScXMLScxmlElt_getParallel, METH_VARARGS, "ScXMLScxmlElt_getParallel(ScXMLScxmlElt self, int idx) -> ScXMLParallelElt"},
	 { "ScXMLScxmlElt_addParallel", _wrap_ScXMLScxmlElt_addParallel, METH_VARARGS, "ScXMLScxmlElt_addParallel(ScXMLScxmlElt self, ScXMLParallelElt state)"},
	 { "ScXMLScxmlElt_removeParallel", _wrap_ScXMLScxmlElt_removeParallel, METH_VARARGS, "ScXMLScxmlElt_removeParallel(ScXMLScxmlElt self, ScXMLParallelElt state)"},
	 { "ScXMLScxmlElt_clearAllParallels", _wrap_ScXMLScxmlElt_clearAllParallels, METH_O, "ScXMLScxmlElt_clearAllParallels(ScXMLScxmlElt self)"},
	 { "ScXMLScxmlElt_getNumFinals", _wrap_ScXMLScxmlElt_getNumFinals, METH_O, "ScXMLScxmlElt_getNumFinals(ScXMLScxmlElt self) -> int"},
	 { "ScXMLScxmlElt_getFinal", _wrap_ScXMLScxmlElt_getFinal, METH_VARARGS, "ScXMLScxmlElt_getFinal(ScXMLScxmlElt self, int idx) -> ScXMLFinalElt"},
	 { "ScXMLScxmlElt_addFinal", _wrap_ScXMLScxmlElt_addFinal, METH_VARARGS, "ScXMLScxmlElt_addFinal(ScXMLScxmlElt self, ScXMLFinalElt state)"},
	 { "ScXMLScxmlElt_removeFinal", _wrap_ScXMLScxmlElt_removeFinal, METH_VARARGS, "ScXMLScxmlElt_removeFinal(ScXMLScxmlElt self, ScXMLFinalElt state)"},
	 { "ScXMLScxmlElt_clearAllFinals", _wrap_ScXMLScxmlElt_clearAllFinals, METH_O, "ScXMLScxmlElt_clearAllFinals(ScXMLScxmlElt self)"},
	 { "ScXMLScxmlElt_setDataModel", _wrap_ScXMLScxmlElt_setDataModel, METH_VARARGS, "ScXMLScxmlElt_setDataModel(ScXMLScxmlElt self, ScXMLDataModelElt datamodel)"},
	 { "ScXMLScxmlElt_getDataModel", _wrap_ScXMLScxmlElt_getDataModel, METH_O, "ScXMLScxmlElt_getDataModel(ScXMLScxmlElt self) -> ScXMLDataModelElt"},
	 { "ScXMLScxmlElt_getNumScripts", _wrap_ScXMLScxmlElt_getNumScripts, METH_O, "ScXMLScxmlElt_getNumScripts(ScXMLScxmlElt self) -> int"},
	 { "ScXMLScxmlElt_getScript", _wrap_ScXMLScxmlElt_getScript, METH_VARARGS, "ScXMLScxmlElt_getScript(ScXMLScxmlElt self, int idx) -> ScXMLScriptElt"},
	 { "ScXMLScxmlElt_addScript", _wrap_ScXMLScxmlElt_addScript, METH_VARARGS, "ScXMLScxmlElt_addScript(ScXMLScxmlElt self, ScXMLScriptElt state)"},
	 { "ScXMLScxmlElt_removeScript", _wrap_ScXMLScxmlElt_removeScript, METH_VARARGS, "ScXMLScxmlElt_removeScript(ScXMLScxmlElt self, ScXMLScriptElt state)"},
	 { "ScXMLScxmlElt_clearAllScripts", _wrap_ScXMLScxmlElt_clearAllScripts, METH_O, "ScXMLScxmlElt_clearAllScripts(ScXMLScxmlElt self)"},
	 { "ScXMLScxmlElt_execute", _wrap_ScXMLScxmlElt_execute, METH_VARARGS, "ScXMLScxmlElt_execute(ScXMLScxmlElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLScxmlElt_swigregister", ScXMLScxmlElt_swigregister, METH_O, NULL},
	 { "ScXMLScxmlElt_swiginit", ScXMLScxmlElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLSendElt_getElementReader", _wrap_ScXMLSendElt_getElementReader, METH_NOARGS, "ScXMLSendElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLSendElt_getClassTypeId", _wrap_ScXMLSendElt_getClassTypeId, METH_NOARGS, "ScXMLSendElt_getClassTypeId() -> SoType"},
	 { "ScXMLSendElt_getTypeId", _wrap_ScXMLSendElt_getTypeId, METH_O, "ScXMLSendElt_getTypeId(ScXMLSendElt self) -> SoType"},
	 { "ScXMLSendElt_createInstance", _wrap_ScXMLSendElt_createInstance, METH_NOARGS, "ScXMLSendElt_createInstance() -> void *"},
	 { "ScXMLSendElt_initClass", _wrap_ScXMLSendElt_initClass, METH_NOARGS, "ScXMLSendElt_initClass()"},
	 { "ScXMLSendElt_cleanClass", _wrap_ScXMLSendElt_cleanClass, METH_NOARGS, "ScXMLSendElt_cleanClass()"},
	 { "new_ScXMLSendElt", _wrap_new_ScXMLSendElt, METH_NOARGS, "new_ScXMLSendElt() -> ScXMLSendElt"},
	 { "delete_ScXMLSendElt", _wrap_delete_ScXMLSendElt, METH_O, "delete_ScXMLSendElt(ScXMLSendElt self)"},
	 { "ScXMLSendElt_setEventAttribute", _wrap_ScXMLSendElt_setEventAttribute, METH_VARARGS, "ScXMLSendElt_setEventAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getEventAttribute", _wrap_ScXMLSendElt_getEventAttribute, METH_O, "ScXMLSendElt_getEventAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setTargetAttribute", _wrap_ScXMLSendElt_setTargetAttribute, METH_VARARGS, "ScXMLSendElt_setTargetAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getTargetAttribute", _wrap_ScXMLSendElt_getTargetAttribute, METH_O, "ScXMLSendElt_getTargetAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setTargetTypeAttribute", _wrap_ScXMLSendElt_setTargetTypeAttribute, METH_VARARGS, "ScXMLSendElt_setTargetTypeAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getTargetTypeAttribute", _wrap_ScXMLSendElt_getTargetTypeAttribute, METH_O, "ScXMLSendElt_getTargetTypeAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setSendIDAttribute", _wrap_ScXMLSendElt_setSendIDAttribute, METH_VARARGS, "ScXMLSendElt_setSendIDAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getSendIDAttribute", _wrap_ScXMLSendElt_getSendIDAttribute, METH_O, "ScXMLSendElt_getSendIDAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setDelayAttribute", _wrap_ScXMLSendElt_setDelayAttribute, METH_VARARGS, "ScXMLSendElt_setDelayAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getDelayAttribute", _wrap_ScXMLSendElt_getDelayAttribute, METH_O, "ScXMLSendElt_getDelayAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setNameListAttribute", _wrap_ScXMLSendElt_setNameListAttribute, METH_VARARGS, "ScXMLSendElt_setNameListAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getNameListAttribute", _wrap_ScXMLSendElt_getNameListAttribute, METH_O, "ScXMLSendElt_getNameListAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_setHintsAttribute", _wrap_ScXMLSendElt_setHintsAttribute, METH_VARARGS, "ScXMLSendElt_setHintsAttribute(ScXMLSendElt self, char const * event)"},
	 { "ScXMLSendElt_getHintsAttribute", _wrap_ScXMLSendElt_getHintsAttribute, METH_O, "ScXMLSendElt_getHintsAttribute(ScXMLSendElt self) -> char const *"},
	 { "ScXMLSendElt_handleXMLAttributes", _wrap_ScXMLSendElt_handleXMLAttributes, METH_O, "ScXMLSendElt_handleXMLAttributes(ScXMLSendElt self) -> SbBool"},
	 { "ScXMLSendElt_copyContents", _wrap_ScXMLSendElt_copyContents, METH_VARARGS, "ScXMLSendElt_copyContents(ScXMLSendElt self, ScXMLElt rhs)"},
	 { "ScXMLSendElt_search", _wrap_ScXMLSendElt_search, METH_VARARGS, "ScXMLSendElt_search(ScXMLSendElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLSendElt_createEvent", _wrap_ScXMLSendElt_createEvent, METH_VARARGS, "ScXMLSendElt_createEvent(ScXMLSendElt self, ScXMLEventTarget host) -> ScXMLEvent"},
	 { "ScXMLSendElt_execute", _wrap_ScXMLSendElt_execute, METH_VARARGS, "ScXMLSendElt_execute(ScXMLSendElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLSendElt_swigregister", ScXMLSendElt_swigregister, METH_O, NULL},
	 { "ScXMLSendElt_swiginit", ScXMLSendElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLStateElt_getElementReader", _wrap_ScXMLStateElt_getElementReader, METH_NOARGS, "ScXMLStateElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLStateElt_getClassTypeId", _wrap_ScXMLStateElt_getClassTypeId, METH_NOARGS, "ScXMLStateElt_getClassTypeId() -> SoType"},
	 { "ScXMLStateElt_getTypeId", _wrap_ScXMLStateElt_getTypeId, METH_O, "ScXMLStateElt_getTypeId(ScXMLStateElt self) -> SoType"},
	 { "ScXMLStateElt_createInstance", _wrap_ScXMLStateElt_createInstance, METH_NOARGS, "ScXMLStateElt_createInstance() -> void *"},
	 { "ScXMLStateElt_initClass", _wrap_ScXMLStateElt_initClass, METH_NOARGS, "ScXMLStateElt_initClass()"},
	 { "ScXMLStateElt_cleanClass", _wrap_ScXMLStateElt_cleanClass, METH_NOARGS, "ScXMLStateElt_cleanClass()"},
	 { "new_ScXMLStateElt", _wrap_new_ScXMLStateElt, METH_NOARGS, "new_ScXMLStateElt() -> ScXMLStateElt"},
	 { "delete_ScXMLStateElt", _wrap_delete_ScXMLStateElt, METH_O, "delete_ScXMLStateElt(ScXMLStateElt self)"},
	 { "ScXMLStateElt_setSrcAttribute", _wrap_ScXMLStateElt_setSrcAttribute, METH_VARARGS, "ScXMLStateElt_setSrcAttribute(ScXMLStateElt self, char const * src)"},
	 { "ScXMLStateElt_getSrcAttribute", _wrap_ScXMLStateElt_getSrcAttribute, METH_O, "ScXMLStateElt_getSrcAttribute(ScXMLStateElt self) -> char const *"},
	 { "ScXMLStateElt_setInitialAttribute", _wrap_ScXMLStateElt_setInitialAttribute, METH_VARARGS, "ScXMLStateElt_setInitialAttribute(ScXMLStateElt self, char const * initial)"},
	 { "ScXMLStateElt_getInitialAttribute", _wrap_ScXMLStateElt_getInitialAttribute, METH_O, "ScXMLStateElt_getInitialAttribute(ScXMLStateElt self) -> char const *"},
	 { "ScXMLStateElt_handleXMLAttributes", _wrap_ScXMLStateElt_handleXMLAttributes, METH_O, "ScXMLStateElt_handleXMLAttributes(ScXMLStateElt self) -> SbBool"},
	 { "ScXMLStateElt_copyContents", _wrap_ScXMLStateElt_copyContents, METH_VARARGS, "ScXMLStateElt_copyContents(ScXMLStateElt self, ScXMLElt rhs)"},
	 { "ScXMLStateElt_search", _wrap_ScXMLStateElt_search, METH_VARARGS, "ScXMLStateElt_search(ScXMLStateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLStateElt_setOnEntry", _wrap_ScXMLStateElt_setOnEntry, METH_VARARGS, "ScXMLStateElt_setOnEntry(ScXMLStateElt self, ScXMLOnEntryElt onentry)"},
	 { "ScXMLStateElt_getOnEntry", _wrap_ScXMLStateElt_getOnEntry, METH_O, "ScXMLStateElt_getOnEntry(ScXMLStateElt self) -> ScXMLOnEntryElt"},
	 { "ScXMLStateElt_setOnExit", _wrap_ScXMLStateElt_setOnExit, METH_VARARGS, "ScXMLStateElt_setOnExit(ScXMLStateElt self, ScXMLOnExitElt onexit)"},
	 { "ScXMLStateElt_getOnExit", _wrap_ScXMLStateElt_getOnExit, METH_O, "ScXMLStateElt_getOnExit(ScXMLStateElt self) -> ScXMLOnExitElt"},
	 { "ScXMLStateElt_getNumTransitions", _wrap_ScXMLStateElt_getNumTransitions, METH_O, "ScXMLStateElt_getNumTransitions(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getTransition", _wrap_ScXMLStateElt_getTransition, METH_VARARGS, "ScXMLStateElt_getTransition(ScXMLStateElt self, int idx) -> ScXMLTransitionElt"},
	 { "ScXMLStateElt_addTransition", _wrap_ScXMLStateElt_addTransition, METH_VARARGS, "ScXMLStateElt_addTransition(ScXMLStateElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLStateElt_removeTransition", _wrap_ScXMLStateElt_removeTransition, METH_VARARGS, "ScXMLStateElt_removeTransition(ScXMLStateElt self, ScXMLTransitionElt transition)"},
	 { "ScXMLStateElt_clearAllTransitions", _wrap_ScXMLStateElt_clearAllTransitions, METH_O, "ScXMLStateElt_clearAllTransitions(ScXMLStateElt self)"},
	 { "ScXMLStateElt_setInitial", _wrap_ScXMLStateElt_setInitial, METH_VARARGS, "ScXMLStateElt_setInitial(ScXMLStateElt self, ScXMLInitialElt initial)"},
	 { "ScXMLStateElt_getInitial", _wrap_ScXMLStateElt_getInitial, METH_O, "ScXMLStateElt_getInitial(ScXMLStateElt self) -> ScXMLInitialElt"},
	 { "ScXMLStateElt_getNumStates", _wrap_ScXMLStateElt_getNumStates, METH_O, "ScXMLStateElt_getNumStates(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getState", _wrap_ScXMLStateElt_getState, METH_VARARGS, "ScXMLStateElt_getState(ScXMLStateElt self, int idx) -> ScXMLStateElt"},
	 { "ScXMLStateElt_addState", _wrap_ScXMLStateElt_addState, METH_VARARGS, "ScXMLStateElt_addState(ScXMLStateElt self, ScXMLStateElt state)"},
	 { "ScXMLStateElt_removeState", _wrap_ScXMLStateElt_removeState, METH_VARARGS, "ScXMLStateElt_removeState(ScXMLStateElt self, ScXMLStateElt state)"},
	 { "ScXMLStateElt_clearAllStates", _wrap_ScXMLStateElt_clearAllStates, METH_O, "ScXMLStateElt_clearAllStates(ScXMLStateElt self)"},
	 { "ScXMLStateElt_getNumParallels", _wrap_ScXMLStateElt_getNumParallels, METH_O, "ScXMLStateElt_getNumParallels(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getParallel", _wrap_ScXMLStateElt_getParallel, METH_VARARGS, "ScXMLStateElt_getParallel(ScXMLStateElt self, int idx) -> ScXMLParallelElt"},
	 { "ScXMLStateElt_addParallel", _wrap_ScXMLStateElt_addParallel, METH_VARARGS, "ScXMLStateElt_addParallel(ScXMLStateElt self, ScXMLParallelElt state)"},
	 { "ScXMLStateElt_removeParallel", _wrap_ScXMLStateElt_removeParallel, METH_VARARGS, "ScXMLStateElt_removeParallel(ScXMLStateElt self, ScXMLParallelElt state)"},
	 { "ScXMLStateElt_clearAllParallels", _wrap_ScXMLStateElt_clearAllParallels, METH_O, "ScXMLStateElt_clearAllParallels(ScXMLStateElt self)"},
	 { "ScXMLStateElt_getNumFinals", _wrap_ScXMLStateElt_getNumFinals, METH_O, "ScXMLStateElt_getNumFinals(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getFinal", _wrap_ScXMLStateElt_getFinal, METH_VARARGS, "ScXMLStateElt_getFinal(ScXMLStateElt self, int idx) -> ScXMLFinalElt"},
	 { "ScXMLStateElt_addFinal", _wrap_ScXMLStateElt_addFinal, METH_VARARGS, "ScXMLStateElt_addFinal(ScXMLStateElt self, ScXMLFinalElt state)"},
	 { "ScXMLStateElt_removeFinal", _wrap_ScXMLStateElt_removeFinal, METH_VARARGS, "ScXMLStateElt_removeFinal(ScXMLStateElt self, ScXMLFinalElt state)"},
	 { "ScXMLStateElt_clearAllFinals", _wrap_ScXMLStateElt_clearAllFinals, METH_O, "ScXMLStateElt_clearAllFinals(ScXMLStateElt self)"},
	 { "ScXMLStateElt_getNumHistories", _wrap_ScXMLStateElt_getNumHistories, METH_O, "ScXMLStateElt_getNumHistories(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getHistory", _wrap_ScXMLStateElt_getHistory, METH_VARARGS, "ScXMLStateElt_getHistory(ScXMLStateElt self, int idx) -> ScXMLHistoryElt"},
	 { "ScXMLStateElt_addHistory", _wrap_ScXMLStateElt_addHistory, METH_VARARGS, "ScXMLStateElt_addHistory(ScXMLStateElt self, ScXMLHistoryElt history)"},
	 { "ScXMLStateElt_removeHistory", _wrap_ScXMLStateElt_removeHistory, METH_VARARGS, "ScXMLStateElt_removeHistory(ScXMLStateElt self, ScXMLHistoryElt history)"},
	 { "ScXMLStateElt_clearAllHistories", _wrap_ScXMLStateElt_clearAllHistories, METH_O, "ScXMLStateElt_clearAllHistories(ScXMLStateElt self)"},
	 { "ScXMLStateElt_getNumAnchors", _wrap_ScXMLStateElt_getNumAnchors, METH_O, "ScXMLStateElt_getNumAnchors(ScXMLStateElt self) -> int"},
	 { "ScXMLStateElt_getAnchor", _wrap_ScXMLStateElt_getAnchor, METH_VARARGS, "ScXMLStateElt_getAnchor(ScXMLStateElt self, int idx) -> ScXMLAnchorElt"},
	 { "ScXMLStateElt_addAnchor", _wrap_ScXMLStateElt_addAnchor, METH_VARARGS, "ScXMLStateElt_addAnchor(ScXMLStateElt self, ScXMLAnchorElt anchor)"},
	 { "ScXMLStateElt_removeAnchor", _wrap_ScXMLStateElt_removeAnchor, METH_VARARGS, "ScXMLStateElt_removeAnchor(ScXMLStateElt self, ScXMLAnchorElt anchor)"},
	 { "ScXMLStateElt_clearAllAnchors", _wrap_ScXMLStateElt_clearAllAnchors, METH_O, "ScXMLStateElt_clearAllAnchors(ScXMLStateElt self)"},
	 { "ScXMLStateElt_setDataModel", _wrap_ScXMLStateElt_setDataModel, METH_VARARGS, "ScXMLStateElt_setDataModel(ScXMLStateElt self, ScXMLDataModelElt datamodel)"},
	 { "ScXMLStateElt_getDataModel", _wrap_ScXMLStateElt_getDataModel, METH_O, "ScXMLStateElt_getDataModel(ScXMLStateElt self) -> ScXMLDataModelElt"},
	 { "ScXMLStateElt_isAtomicState", _wrap_ScXMLStateElt_isAtomicState, METH_O, "ScXMLStateElt_isAtomicState(ScXMLStateElt self) -> SbBool"},
	 { "ScXMLStateElt_swigregister", ScXMLStateElt_swigregister, METH_O, NULL},
	 { "ScXMLStateElt_swiginit", ScXMLStateElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLStateMachine_getClassTypeId", _wrap_ScXMLStateMachine_getClassTypeId, METH_NOARGS, "ScXMLStateMachine_getClassTypeId() -> SoType"},
	 { "ScXMLStateMachine_getTypeId", _wrap_ScXMLStateMachine_getTypeId, METH_O, "ScXMLStateMachine_getTypeId(ScXMLStateMachine self) -> SoType"},
	 { "ScXMLStateMachine_createInstance", _wrap_ScXMLStateMachine_createInstance, METH_NOARGS, "ScXMLStateMachine_createInstance() -> void *"},
	 { "ScXMLStateMachine_initClass", _wrap_ScXMLStateMachine_initClass, METH_NOARGS, "ScXMLStateMachine_initClass()"},
	 { "ScXMLStateMachine_cleanClass", _wrap_ScXMLStateMachine_cleanClass, METH_NOARGS, "ScXMLStateMachine_cleanClass()"},
	 { "new_ScXMLStateMachine", _wrap_new_ScXMLStateMachine, METH_NOARGS, "new_ScXMLStateMachine() -> ScXMLStateMachine"},
	 { "delete_ScXMLStateMachine", _wrap_delete_ScXMLStateMachine, METH_O, "delete_ScXMLStateMachine(ScXMLStateMachine self)"},
	 { "ScXMLStateMachine_setName", _wrap_ScXMLStateMachine_setName, METH_VARARGS, "ScXMLStateMachine_setName(ScXMLStateMachine self, SbName name)"},
	 { "ScXMLStateMachine_getName", _wrap_ScXMLStateMachine_getName, METH_O, "ScXMLStateMachine_getName(ScXMLStateMachine self) -> SbName"},
	 { "ScXMLStateMachine_setDescription", _wrap_ScXMLStateMachine_setDescription, METH_VARARGS, "ScXMLStateMachine_setDescription(ScXMLStateMachine self, ScXMLDocument document)"},
	 { "ScXMLStateMachine_getDescription", _wrap_ScXMLStateMachine_getDescription, METH_O, "ScXMLStateMachine_getDescription(ScXMLStateMachine self) -> ScXMLDocument"},
	 { "ScXMLStateMachine_setSessionId", _wrap_ScXMLStateMachine_setSessionId, METH_VARARGS, "ScXMLStateMachine_setSessionId(ScXMLStateMachine self, SbName sessionid)"},
	 { "ScXMLStateMachine_getSessionId", _wrap_ScXMLStateMachine_getSessionId, METH_O, "ScXMLStateMachine_getSessionId(ScXMLStateMachine self) -> SbName"},
	 { "ScXMLStateMachine_initialize", _wrap_ScXMLStateMachine_initialize, METH_O, "ScXMLStateMachine_initialize(ScXMLStateMachine self)"},
	 { "ScXMLStateMachine_isActive", _wrap_ScXMLStateMachine_isActive, METH_O, "ScXMLStateMachine_isActive(ScXMLStateMachine self) -> SbBool"},
	 { "ScXMLStateMachine_isFinished", _wrap_ScXMLStateMachine_isFinished, METH_O, "ScXMLStateMachine_isFinished(ScXMLStateMachine self) -> SbBool"},
	 { "ScXMLStateMachine_getNumActiveStates", _wrap_ScXMLStateMachine_getNumActiveStates, METH_O, "ScXMLStateMachine_getNumActiveStates(ScXMLStateMachine self) -> int"},
	 { "ScXMLStateMachine_getActiveState", _wrap_ScXMLStateMachine_getActiveState, METH_VARARGS, "ScXMLStateMachine_getActiveState(ScXMLStateMachine self, int idx) -> ScXMLElt"},
	 { "ScXMLStateMachine_setVariable", _wrap_ScXMLStateMachine_setVariable, METH_VARARGS, "ScXMLStateMachine_setVariable(ScXMLStateMachine self, char const * name, char const * value)"},
	 { "ScXMLStateMachine_getVariable", _wrap_ScXMLStateMachine_getVariable, METH_VARARGS, "ScXMLStateMachine_getVariable(ScXMLStateMachine self, char const * name) -> char const *"},
	 { "ScXMLStateMachine_getStateMachineForSessionId", _wrap_ScXMLStateMachine_getStateMachineForSessionId, METH_O, "ScXMLStateMachine_getStateMachineForSessionId(SbName sessionid) -> ScXMLStateMachine"},
	 { "ScXMLStateMachine_setLogLevel", _wrap_ScXMLStateMachine_setLogLevel, METH_VARARGS, "ScXMLStateMachine_setLogLevel(ScXMLStateMachine self, int loglevel)"},
	 { "ScXMLStateMachine_getLogLevel", _wrap_ScXMLStateMachine_getLogLevel, METH_O, "ScXMLStateMachine_getLogLevel(ScXMLStateMachine self) -> int"},
	 { "ScXMLStateMachine_setEvaluator", _wrap_ScXMLStateMachine_setEvaluator, METH_VARARGS, "ScXMLStateMachine_setEvaluator(ScXMLStateMachine self, ScXMLEvaluator evaluator)"},
	 { "ScXMLStateMachine_getEvaluator", _wrap_ScXMLStateMachine_getEvaluator, METH_O, "ScXMLStateMachine_getEvaluator(ScXMLStateMachine self) -> ScXMLEvaluator"},
	 { "ScXMLStateMachine_isModuleEnabled", _wrap_ScXMLStateMachine_isModuleEnabled, METH_VARARGS, "ScXMLStateMachine_isModuleEnabled(ScXMLStateMachine self, char const * modulename) -> SbBool"},
	 { "ScXMLStateMachine_getNumEnabledModules", _wrap_ScXMLStateMachine_getNumEnabledModules, METH_O, "ScXMLStateMachine_getNumEnabledModules(ScXMLStateMachine self) -> int"},
	 { "ScXMLStateMachine_getEnabledModuleName", _wrap_ScXMLStateMachine_getEnabledModuleName, METH_VARARGS, "ScXMLStateMachine_getEnabledModuleName(ScXMLStateMachine self, int idx) -> char const *"},
	 { "ScXMLStateMachine_setEnabledModulesList", _wrap_ScXMLStateMachine_setEnabledModulesList, METH_VARARGS, "ScXMLStateMachine_setEnabledModulesList(ScXMLStateMachine self, SbList< char const * > const & modulenames)"},
	 { "ScXMLStateMachine_addDeleteCallback", _wrap_ScXMLStateMachine_addDeleteCallback, METH_VARARGS, "\n"
		"ScXMLStateMachine_addDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)\n"
		"ScXMLStateMachine_addDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "ScXMLStateMachine_removeDeleteCallback", _wrap_ScXMLStateMachine_removeDeleteCallback, METH_VARARGS, "\n"
		"ScXMLStateMachine_removeDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)\n"
		"ScXMLStateMachine_removeDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "ScXMLStateMachine_addStateChangeCallback", _wrap_ScXMLStateMachine_addStateChangeCallback, METH_VARARGS, "\n"
		"ScXMLStateMachine_addStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)\n"
		"ScXMLStateMachine_addStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "ScXMLStateMachine_removeStateChangeCallback", _wrap_ScXMLStateMachine_removeStateChangeCallback, METH_VARARGS, "\n"
		"ScXMLStateMachine_removeStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)\n"
		"ScXMLStateMachine_removeStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)\n"
		""},
	 { "ScXMLStateMachine_swigregister", ScXMLStateMachine_swigregister, METH_O, NULL},
	 { "ScXMLStateMachine_swiginit", ScXMLStateMachine_swiginit, METH_VARARGS, NULL},
	 { "ScXMLTransitionElt_getElementReader", _wrap_ScXMLTransitionElt_getElementReader, METH_NOARGS, "ScXMLTransitionElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLTransitionElt_getClassTypeId", _wrap_ScXMLTransitionElt_getClassTypeId, METH_NOARGS, "ScXMLTransitionElt_getClassTypeId() -> SoType"},
	 { "ScXMLTransitionElt_getTypeId", _wrap_ScXMLTransitionElt_getTypeId, METH_O, "ScXMLTransitionElt_getTypeId(ScXMLTransitionElt self) -> SoType"},
	 { "ScXMLTransitionElt_createInstance", _wrap_ScXMLTransitionElt_createInstance, METH_NOARGS, "ScXMLTransitionElt_createInstance() -> void *"},
	 { "ScXMLTransitionElt_initClass", _wrap_ScXMLTransitionElt_initClass, METH_NOARGS, "ScXMLTransitionElt_initClass()"},
	 { "ScXMLTransitionElt_cleanClass", _wrap_ScXMLTransitionElt_cleanClass, METH_NOARGS, "ScXMLTransitionElt_cleanClass()"},
	 { "new_ScXMLTransitionElt", _wrap_new_ScXMLTransitionElt, METH_NOARGS, "new_ScXMLTransitionElt() -> ScXMLTransitionElt"},
	 { "delete_ScXMLTransitionElt", _wrap_delete_ScXMLTransitionElt, METH_O, "delete_ScXMLTransitionElt(ScXMLTransitionElt self)"},
	 { "ScXMLTransitionElt_setEventAttribute", _wrap_ScXMLTransitionElt_setEventAttribute, METH_VARARGS, "ScXMLTransitionElt_setEventAttribute(ScXMLTransitionElt self, char const * event)"},
	 { "ScXMLTransitionElt_getEventAttribute", _wrap_ScXMLTransitionElt_getEventAttribute, METH_O, "ScXMLTransitionElt_getEventAttribute(ScXMLTransitionElt self) -> char const *"},
	 { "ScXMLTransitionElt_setCondAttribute", _wrap_ScXMLTransitionElt_setCondAttribute, METH_VARARGS, "ScXMLTransitionElt_setCondAttribute(ScXMLTransitionElt self, char const * cond)"},
	 { "ScXMLTransitionElt_getCondAttribute", _wrap_ScXMLTransitionElt_getCondAttribute, METH_O, "ScXMLTransitionElt_getCondAttribute(ScXMLTransitionElt self) -> char const *"},
	 { "ScXMLTransitionElt_setTargetAttribute", _wrap_ScXMLTransitionElt_setTargetAttribute, METH_VARARGS, "ScXMLTransitionElt_setTargetAttribute(ScXMLTransitionElt self, char const * target)"},
	 { "ScXMLTransitionElt_getTargetAttribute", _wrap_ScXMLTransitionElt_getTargetAttribute, METH_O, "ScXMLTransitionElt_getTargetAttribute(ScXMLTransitionElt self) -> char const *"},
	 { "ScXMLTransitionElt_setAnchorAttribute", _wrap_ScXMLTransitionElt_setAnchorAttribute, METH_VARARGS, "ScXMLTransitionElt_setAnchorAttribute(ScXMLTransitionElt self, char const * anchor)"},
	 { "ScXMLTransitionElt_getAnchorAttribute", _wrap_ScXMLTransitionElt_getAnchorAttribute, METH_O, "ScXMLTransitionElt_getAnchorAttribute(ScXMLTransitionElt self) -> char const *"},
	 { "ScXMLTransitionElt_handleXMLAttributes", _wrap_ScXMLTransitionElt_handleXMLAttributes, METH_O, "ScXMLTransitionElt_handleXMLAttributes(ScXMLTransitionElt self) -> SbBool"},
	 { "ScXMLTransitionElt_copyContents", _wrap_ScXMLTransitionElt_copyContents, METH_VARARGS, "ScXMLTransitionElt_copyContents(ScXMLTransitionElt self, ScXMLElt rhs)"},
	 { "ScXMLTransitionElt_search", _wrap_ScXMLTransitionElt_search, METH_VARARGS, "ScXMLTransitionElt_search(ScXMLTransitionElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLTransitionElt_isConditionLess", _wrap_ScXMLTransitionElt_isConditionLess, METH_O, "ScXMLTransitionElt_isConditionLess(ScXMLTransitionElt self) -> SbBool"},
	 { "ScXMLTransitionElt_isTargetLess", _wrap_ScXMLTransitionElt_isTargetLess, METH_O, "ScXMLTransitionElt_isTargetLess(ScXMLTransitionElt self) -> SbBool"},
	 { "ScXMLTransitionElt_isSelfReferencing", _wrap_ScXMLTransitionElt_isSelfReferencing, METH_O, "ScXMLTransitionElt_isSelfReferencing(ScXMLTransitionElt self) -> SbBool"},
	 { "ScXMLTransitionElt_isEventMatch", _wrap_ScXMLTransitionElt_isEventMatch, METH_VARARGS, "ScXMLTransitionElt_isEventMatch(ScXMLTransitionElt self, ScXMLEvent event) -> SbBool"},
	 { "ScXMLTransitionElt_evaluateCondition", _wrap_ScXMLTransitionElt_evaluateCondition, METH_VARARGS, "ScXMLTransitionElt_evaluateCondition(ScXMLTransitionElt self, ScXMLStateMachine statemachine) -> SbBool"},
	 { "ScXMLTransitionElt_getNumExecutables", _wrap_ScXMLTransitionElt_getNumExecutables, METH_O, "ScXMLTransitionElt_getNumExecutables(ScXMLTransitionElt self) -> int"},
	 { "ScXMLTransitionElt_getExecutable", _wrap_ScXMLTransitionElt_getExecutable, METH_VARARGS, "ScXMLTransitionElt_getExecutable(ScXMLTransitionElt self, int idx) -> ScXMLExecutableElt"},
	 { "ScXMLTransitionElt_addExecutable", _wrap_ScXMLTransitionElt_addExecutable, METH_VARARGS, "ScXMLTransitionElt_addExecutable(ScXMLTransitionElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLTransitionElt_removeExecutable", _wrap_ScXMLTransitionElt_removeExecutable, METH_VARARGS, "ScXMLTransitionElt_removeExecutable(ScXMLTransitionElt self, ScXMLExecutableElt executable)"},
	 { "ScXMLTransitionElt_clearAllExecutables", _wrap_ScXMLTransitionElt_clearAllExecutables, METH_O, "ScXMLTransitionElt_clearAllExecutables(ScXMLTransitionElt self)"},
	 { "ScXMLTransitionElt_execute", _wrap_ScXMLTransitionElt_execute, METH_VARARGS, "ScXMLTransitionElt_execute(ScXMLTransitionElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLTransitionElt_swigregister", ScXMLTransitionElt_swigregister, METH_O, NULL},
	 { "ScXMLTransitionElt_swiginit", ScXMLTransitionElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLValidateElt_getElementReader", _wrap_ScXMLValidateElt_getElementReader, METH_NOARGS, "ScXMLValidateElt_getElementReader() -> ScXMLEltReader"},
	 { "ScXMLValidateElt_getClassTypeId", _wrap_ScXMLValidateElt_getClassTypeId, METH_NOARGS, "ScXMLValidateElt_getClassTypeId() -> SoType"},
	 { "ScXMLValidateElt_getTypeId", _wrap_ScXMLValidateElt_getTypeId, METH_O, "ScXMLValidateElt_getTypeId(ScXMLValidateElt self) -> SoType"},
	 { "ScXMLValidateElt_createInstance", _wrap_ScXMLValidateElt_createInstance, METH_NOARGS, "ScXMLValidateElt_createInstance() -> void *"},
	 { "ScXMLValidateElt_initClass", _wrap_ScXMLValidateElt_initClass, METH_NOARGS, "ScXMLValidateElt_initClass()"},
	 { "ScXMLValidateElt_cleanClass", _wrap_ScXMLValidateElt_cleanClass, METH_NOARGS, "ScXMLValidateElt_cleanClass()"},
	 { "new_ScXMLValidateElt", _wrap_new_ScXMLValidateElt, METH_NOARGS, "new_ScXMLValidateElt() -> ScXMLValidateElt"},
	 { "delete_ScXMLValidateElt", _wrap_delete_ScXMLValidateElt, METH_O, "delete_ScXMLValidateElt(ScXMLValidateElt self)"},
	 { "ScXMLValidateElt_setLocationAttribute", _wrap_ScXMLValidateElt_setLocationAttribute, METH_VARARGS, "ScXMLValidateElt_setLocationAttribute(ScXMLValidateElt self, char const * location)"},
	 { "ScXMLValidateElt_getLocationAttribute", _wrap_ScXMLValidateElt_getLocationAttribute, METH_O, "ScXMLValidateElt_getLocationAttribute(ScXMLValidateElt self) -> char const *"},
	 { "ScXMLValidateElt_setSchemaAttribute", _wrap_ScXMLValidateElt_setSchemaAttribute, METH_VARARGS, "ScXMLValidateElt_setSchemaAttribute(ScXMLValidateElt self, char const * schema)"},
	 { "ScXMLValidateElt_getSchemaAttribute", _wrap_ScXMLValidateElt_getSchemaAttribute, METH_O, "ScXMLValidateElt_getSchemaAttribute(ScXMLValidateElt self) -> char const *"},
	 { "ScXMLValidateElt_handleXMLAttributes", _wrap_ScXMLValidateElt_handleXMLAttributes, METH_O, "ScXMLValidateElt_handleXMLAttributes(ScXMLValidateElt self) -> SbBool"},
	 { "ScXMLValidateElt_copyContents", _wrap_ScXMLValidateElt_copyContents, METH_VARARGS, "ScXMLValidateElt_copyContents(ScXMLValidateElt self, ScXMLElt rhs)"},
	 { "ScXMLValidateElt_search", _wrap_ScXMLValidateElt_search, METH_VARARGS, "ScXMLValidateElt_search(ScXMLValidateElt self, char const * attrname, char const * attrvalue) -> ScXMLElt"},
	 { "ScXMLValidateElt_execute", _wrap_ScXMLValidateElt_execute, METH_VARARGS, "ScXMLValidateElt_execute(ScXMLValidateElt self, ScXMLStateMachine statemachine)"},
	 { "ScXMLValidateElt_swigregister", ScXMLValidateElt_swigregister, METH_O, NULL},
	 { "ScXMLValidateElt_swiginit", ScXMLValidateElt_swiginit, METH_VARARGS, NULL},
	 { "ScXMLXPathEvaluator_getClassTypeId", _wrap_ScXMLXPathEvaluator_getClassTypeId, METH_NOARGS, "ScXMLXPathEvaluator_getClassTypeId() -> SoType"},
	 { "ScXMLXPathEvaluator_getTypeId", _wrap_ScXMLXPathEvaluator_getTypeId, METH_O, "ScXMLXPathEvaluator_getTypeId(ScXMLXPathEvaluator self) -> SoType"},
	 { "ScXMLXPathEvaluator_createInstance", _wrap_ScXMLXPathEvaluator_createInstance, METH_NOARGS, "ScXMLXPathEvaluator_createInstance() -> void *"},
	 { "ScXMLXPathEvaluator_initClass", _wrap_ScXMLXPathEvaluator_initClass, METH_NOARGS, "ScXMLXPathEvaluator_initClass()"},
	 { "ScXMLXPathEvaluator_cleanClass", _wrap_ScXMLXPathEvaluator_cleanClass, METH_NOARGS, "ScXMLXPathEvaluator_cleanClass()"},
	 { "new_ScXMLXPathEvaluator", _wrap_new_ScXMLXPathEvaluator, METH_NOARGS, "new_ScXMLXPathEvaluator() -> ScXMLXPathEvaluator"},
	 { "delete_ScXMLXPathEvaluator", _wrap_delete_ScXMLXPathEvaluator, METH_O, "delete_ScXMLXPathEvaluator(ScXMLXPathEvaluator self)"},
	 { "ScXMLXPathEvaluator_evaluate", _wrap_ScXMLXPathEvaluator_evaluate, METH_VARARGS, "ScXMLXPathEvaluator_evaluate(ScXMLXPathEvaluator self, char const * expression) -> ScXMLDataObj"},
	 { "ScXMLXPathEvaluator_setAtLocation", _wrap_ScXMLXPathEvaluator_setAtLocation, METH_VARARGS, "ScXMLXPathEvaluator_setAtLocation(ScXMLXPathEvaluator self, char const * location, ScXMLDataObj obj) -> SbBool"},
	 { "ScXMLXPathEvaluator_locate", _wrap_ScXMLXPathEvaluator_locate, METH_VARARGS, "ScXMLXPathEvaluator_locate(ScXMLXPathEvaluator self, char const * location) -> ScXMLDataObj"},
	 { "ScXMLXPathEvaluator_swigregister", ScXMLXPathEvaluator_swigregister, METH_O, NULL},
	 { "ScXMLXPathEvaluator_swiginit", ScXMLXPathEvaluator_swiginit, METH_VARARGS, NULL},
	 { "SoScXMLEvent_getClassTypeId", _wrap_SoScXMLEvent_getClassTypeId, METH_NOARGS, "SoScXMLEvent_getClassTypeId() -> SoType"},
	 { "SoScXMLEvent_getTypeId", _wrap_SoScXMLEvent_getTypeId, METH_O, "SoScXMLEvent_getTypeId(SoScXMLEvent self) -> SoType"},
	 { "SoScXMLEvent_createInstance", _wrap_SoScXMLEvent_createInstance, METH_NOARGS, "SoScXMLEvent_createInstance() -> void *"},
	 { "SoScXMLEvent_initClass", _wrap_SoScXMLEvent_initClass, METH_NOARGS, "SoScXMLEvent_initClass()"},
	 { "SoScXMLEvent_cleanClass", _wrap_SoScXMLEvent_cleanClass, METH_NOARGS, "SoScXMLEvent_cleanClass()"},
	 { "new_SoScXMLEvent", _wrap_new_SoScXMLEvent, METH_NOARGS, "new_SoScXMLEvent() -> SoScXMLEvent"},
	 { "delete_SoScXMLEvent", _wrap_delete_SoScXMLEvent, METH_O, "delete_SoScXMLEvent(SoScXMLEvent self)"},
	 { "SoScXMLEvent_setSoEvent", _wrap_SoScXMLEvent_setSoEvent, METH_VARARGS, "SoScXMLEvent_setSoEvent(SoScXMLEvent self, SoEvent soevent)"},
	 { "SoScXMLEvent_getSoEvent", _wrap_SoScXMLEvent_getSoEvent, METH_O, "SoScXMLEvent_getSoEvent(SoScXMLEvent self) -> SoEvent"},
	 { "SoScXMLEvent_setUpIdentifier", _wrap_SoScXMLEvent_setUpIdentifier, METH_O, "SoScXMLEvent_setUpIdentifier(SoScXMLEvent self)"},
	 { "SoScXMLEvent_copyContents", _wrap_SoScXMLEvent_copyContents, METH_VARARGS, "SoScXMLEvent_copyContents(SoScXMLEvent self, ScXMLEvent rhs)"},
	 { "SoScXMLEvent_swigregister", SoScXMLEvent_swigregister, METH_O, NULL},
	 { "SoScXMLEvent_swiginit", SoScXMLEvent_swiginit, METH_VARARGS, NULL},
	 { "SoScXMLStateMachine_getClassTypeId", _wrap_SoScXMLStateMachine_getClassTypeId, METH_NOARGS, "SoScXMLStateMachine_getClassTypeId() -> SoType"},
	 { "SoScXMLStateMachine_getTypeId", _wrap_SoScXMLStateMachine_getTypeId, METH_O, "SoScXMLStateMachine_getTypeId(SoScXMLStateMachine self) -> SoType"},
	 { "SoScXMLStateMachine_createInstance", _wrap_SoScXMLStateMachine_createInstance, METH_NOARGS, "SoScXMLStateMachine_createInstance() -> void *"},
	 { "SoScXMLStateMachine_initClass", _wrap_SoScXMLStateMachine_initClass, METH_NOARGS, "SoScXMLStateMachine_initClass()"},
	 { "SoScXMLStateMachine_cleanClass", _wrap_SoScXMLStateMachine_cleanClass, METH_NOARGS, "SoScXMLStateMachine_cleanClass()"},
	 { "new_SoScXMLStateMachine", _wrap_new_SoScXMLStateMachine, METH_NOARGS, "new_SoScXMLStateMachine() -> SoScXMLStateMachine"},
	 { "delete_SoScXMLStateMachine", _wrap_delete_SoScXMLStateMachine, METH_O, "delete_SoScXMLStateMachine(SoScXMLStateMachine self)"},
	 { "SoScXMLStateMachine_setSceneGraphRoot", _wrap_SoScXMLStateMachine_setSceneGraphRoot, METH_VARARGS, "SoScXMLStateMachine_setSceneGraphRoot(SoScXMLStateMachine self, SoNode root)"},
	 { "SoScXMLStateMachine_getSceneGraphRoot", _wrap_SoScXMLStateMachine_getSceneGraphRoot, METH_O, "SoScXMLStateMachine_getSceneGraphRoot(SoScXMLStateMachine self) -> SoNode"},
	 { "SoScXMLStateMachine_setActiveCamera", _wrap_SoScXMLStateMachine_setActiveCamera, METH_VARARGS, "SoScXMLStateMachine_setActiveCamera(SoScXMLStateMachine self, SoCamera camera)"},
	 { "SoScXMLStateMachine_getActiveCamera", _wrap_SoScXMLStateMachine_getActiveCamera, METH_O, "SoScXMLStateMachine_getActiveCamera(SoScXMLStateMachine self) -> SoCamera"},
	 { "SoScXMLStateMachine_setViewportRegion", _wrap_SoScXMLStateMachine_setViewportRegion, METH_VARARGS, "SoScXMLStateMachine_setViewportRegion(SoScXMLStateMachine self, SbViewportRegion vp)"},
	 { "SoScXMLStateMachine_getViewportRegion", _wrap_SoScXMLStateMachine_getViewportRegion, METH_O, "SoScXMLStateMachine_getViewportRegion(SoScXMLStateMachine self) -> SbViewportRegion"},
	 { "SoScXMLStateMachine_preGLRender", _wrap_SoScXMLStateMachine_preGLRender, METH_O, "SoScXMLStateMachine_preGLRender(SoScXMLStateMachine self)"},
	 { "SoScXMLStateMachine_postGLRender", _wrap_SoScXMLStateMachine_postGLRender, METH_O, "SoScXMLStateMachine_postGLRender(SoScXMLStateMachine self)"},
	 { "SoScXMLStateMachine_processSoEvent", _wrap_SoScXMLStateMachine_processSoEvent, METH_VARARGS, "SoScXMLStateMachine_processSoEvent(SoScXMLStateMachine self, SoEvent event) -> SbBool"},
	 { "SoScXMLStateMachine_getVariable", _wrap_SoScXMLStateMachine_getVariable, METH_VARARGS, "SoScXMLStateMachine_getVariable(SoScXMLStateMachine self, char const * key) -> char const *"},
	 { "SoScXMLStateMachine_swigregister", SoScXMLStateMachine_swigregister, METH_O, NULL},
	 { "SoScXMLStateMachine_swiginit", SoScXMLStateMachine_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_a_2__doublepTo_p_a_2__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[2])  ((doublep (*)[2]) x));
}
static void *_p_a_2__intpTo_p_a_2__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[2])  ((intp (*)[2]) x));
}
static void *_p_a_3__intpTo_p_a_3__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[3])  ((intp (*)[3]) x));
}
static void *_p_a_4__doublepTo_p_a_4__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[4])  ((doublep (*)[4]) x));
}
static void *_p_a_4__floatpTo_p_a_4__float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float (*)[4])  ((floatp (*)[4]) x));
}
static void *_p_a_4__intpTo_p_a_4__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[4])  ((intp (*)[4]) x));
}
static void *_p_p_charpTo_p_p_char(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((char **)  ((charp **) x));
}
static void *_p_doublepTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double *)  ((doublep *) x));
}
static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((intp *) x));
}
static void *_p_SbColorTo_p_SbVec3f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbVec3f *)  ((SbColor *) x));
}
static void *_p_floatpTo_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float *)  ((floatp *) x));
}
static void *_p_p_SoMFBitMaskTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **) (SoMFEnum *) ((SoMFBitMask **) x));
}
static void *_p_p_SoMFBoolTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFBool **) x));
}
static void *_p_p_SoMFColorTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFColor **) x));
}
static void *_p_p_SoMFColorRGBATo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFColorRGBA **) x));
}
static void *_p_p_SoMFDoubleTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFDouble **) x));
}
static void *_p_p_SoMFEngineTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFEngine **) x));
}
static void *_p_p_SoMFEnumTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFEnum **) x));
}
static void *_p_p_SoMFFloatTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFFloat **) x));
}
static void *_p_p_SoMFInt32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFInt32 **) x));
}
static void *_p_p_SoMFMatrixTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFMatrix **) x));
}
static void *_p_p_SoMFNameTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFName **) x));
}
static void *_p_p_SoMFNodeTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFNode **) x));
}
static void *_p_p_SoMFPathTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFPath **) x));
}
static void *_p_p_SoMFPlaneTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFPlane **) x));
}
static void *_p_p_SoMFRotationTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFRotation **) x));
}
static void *_p_p_SoMFShortTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFShort **) x));
}
static void *_p_p_SoMFStringTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFString **) x));
}
static void *_p_p_SoMFTimeTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFTime **) x));
}
static void *_p_p_SoMFUInt32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFUInt32 **) x));
}
static void *_p_p_SoMFUShortTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFUShort **) x));
}
static void *_p_p_SoMFVec2bTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec2b **) x));
}
static void *_p_p_SoMFVec2dTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec2d **) x));
}
static void *_p_p_SoMFVec2fTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec2f **) x));
}
static void *_p_p_SoMFVec2i32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec2i32 **) x));
}
static void *_p_p_SoMFVec2sTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec2s **) x));
}
static void *_p_p_SoMFVec3bTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec3b **) x));
}
static void *_p_p_SoMFVec3dTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec3d **) x));
}
static void *_p_p_SoMFVec3fTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec3f **) x));
}
static void *_p_p_SoMFVec3i32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec3i32 **) x));
}
static void *_p_p_SoMFVec3sTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec3s **) x));
}
static void *_p_p_SoMFVec4bTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4b **) x));
}
static void *_p_p_SoMFVec4dTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4d **) x));
}
static void *_p_p_SoMFVec4fTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4f **) x));
}
static void *_p_p_SoMFVec4i32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4i32 **) x));
}
static void *_p_p_SoMFVec4sTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4s **) x));
}
static void *_p_p_SoMFVec4ubTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4ub **) x));
}
static void *_p_p_SoMFVec4ui32To_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4ui32 **) x));
}
static void *_p_p_SoMFVec4usTo_p_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField **)  ((SoMFVec4us **) x));
}
static void *_p_SbXfBox3fTo_p_SbBox3f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbBox3f *)  ((SbXfBox3f *) x));
}
static void *_p_SbCylinderPlaneProjectorTo_p_SbCylinderProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbCylinderProjector *) (SbCylinderSectionProjector *) ((SbCylinderPlaneProjector *) x));
}
static void *_p_SbCylinderSectionProjectorTo_p_SbCylinderProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbCylinderProjector *)  ((SbCylinderSectionProjector *) x));
}
static void *_p_SbCylinderSheetProjectorTo_p_SbCylinderProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbCylinderProjector *)  ((SbCylinderSheetProjector *) x));
}
static void *_p_SbCylinderPlaneProjectorTo_p_SbCylinderSectionProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbCylinderSectionProjector *)  ((SbCylinderPlaneProjector *) x));
}
static void *_p_SbIntListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SbIntList *) x));
}
static void *_p_SbStringListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SbStringList *) x));
}
static void *_p_SbVec3fListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SbVec3fList *) x));
}
static void *_p_SoActionMethodListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoActionMethodList *) x));
}
static void *_p_SoAuditorListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoAuditorList *) x));
}
static void *_p_SoBaseListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoBaseList *) x));
}
static void *_p_SoChildListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *) (SoBaseList *)(SoNodeList *) ((SoChildList *) x));
}
static void *_p_SoDetailListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoDetailList *) x));
}
static void *_p_SoEngineListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *) (SoBaseList *) ((SoEngineList *) x));
}
static void *_p_SoEngineOutputListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoEngineOutputList *) x));
}
static void *_p_SoFieldListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoFieldList *) x));
}
static void *_p_SoNodeListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *) (SoBaseList *) ((SoNodeList *) x));
}
static void *_p_SoPathListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *) (SoBaseList *) ((SoPathList *) x));
}
static void *_p_SoPickedPointListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoPickedPointList *) x));
}
static void *_p_SoTypeListTo_p_SbPList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbPList *)  ((SoTypeList *) x));
}
static void *_p_SbCylinderPlaneProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbCylinderProjector *)(SbCylinderSectionProjector *) ((SbCylinderPlaneProjector *) x));
}
static void *_p_SbCylinderProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *)  ((SbCylinderProjector *) x));
}
static void *_p_SbCylinderSectionProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbCylinderProjector *) ((SbCylinderSectionProjector *) x));
}
static void *_p_SbCylinderSheetProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbCylinderProjector *) ((SbCylinderSheetProjector *) x));
}
static void *_p_SbLineProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *)  ((SbLineProjector *) x));
}
static void *_p_SbPlaneProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *)  ((SbPlaneProjector *) x));
}
static void *_p_SbSpherePlaneProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbSphereProjector *)(SbSphereSectionProjector *) ((SbSpherePlaneProjector *) x));
}
static void *_p_SbSphereProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *)  ((SbSphereProjector *) x));
}
static void *_p_SbSphereSectionProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbSphereProjector *) ((SbSphereSectionProjector *) x));
}
static void *_p_SbSphereSheetProjectorTo_p_SbProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbProjector *) (SbSphereProjector *) ((SbSphereSheetProjector *) x));
}
static void *_p_SbSpherePlaneProjectorTo_p_SbSphereProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbSphereProjector *) (SbSphereSectionProjector *) ((SbSpherePlaneProjector *) x));
}
static void *_p_SbSphereSectionProjectorTo_p_SbSphereProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbSphereProjector *)  ((SbSphereSectionProjector *) x));
}
static void *_p_SbSphereSheetProjectorTo_p_SbSphereProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbSphereProjector *)  ((SbSphereSheetProjector *) x));
}
static void *_p_SbSpherePlaneProjectorTo_p_SbSphereSectionProjector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbSphereSectionProjector *)  ((SbSpherePlaneProjector *) x));
}
static void *_p_SbColor4fTo_p_SbVec4f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbVec4f *)  ((SbColor4f *) x));
}
static void *_p_ScXMLFinalEltTo_p_ScXMLAbstractStateElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLAbstractStateElt *)  ((ScXMLFinalElt *) x));
}
static void *_p_ScXMLParallelEltTo_p_ScXMLAbstractStateElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLAbstractStateElt *)  ((ScXMLParallelElt *) x));
}
static void *_p_ScXMLStateEltTo_p_ScXMLAbstractStateElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLAbstractStateElt *)  ((ScXMLStateElt *) x));
}
static void *_p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLAddOpExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLAddOpExprDataObj *)  ((ScXMLCoinAddOpExprDataObj *) x));
}
static void *_p_ScXMLBoolDataObjTo_p_ScXMLConstantDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLConstantDataObj *)  ((ScXMLBoolDataObj *) x));
}
static void *_p_ScXMLRealDataObjTo_p_ScXMLConstantDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLConstantDataObj *)  ((ScXMLRealDataObj *) x));
}
static void *_p_ScXMLSbDataObjTo_p_ScXMLConstantDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLConstantDataObj *)  ((ScXMLSbDataObj *) x));
}
static void *_p_ScXMLStringDataObjTo_p_ScXMLConstantDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLConstantDataObj *)  ((ScXMLStringDataObj *) x));
}
static void *_p_ScXMLAddOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLAddOpExprDataObj *) x));
}
static void *_p_ScXMLAndOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLAndOpExprDataObj *) x));
}
static void *_p_ScXMLAppendOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLAppendOpExprDataObj *) x));
}
static void *_p_ScXMLBoolDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLConstantDataObj *) ((ScXMLBoolDataObj *) x));
}
static void *_p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLAddOpExprDataObj *) ((ScXMLCoinAddOpExprDataObj *) x));
}
static void *_p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLDivideOpExprDataObj *) ((ScXMLCoinDivideOpExprDataObj *) x));
}
static void *_p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLEqualsOpExprDataObj *) ((ScXMLCoinEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLCoinLengthFuncExprDataObj *) x));
}
static void *_p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLMultiplyOpExprDataObj *) ((ScXMLCoinMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLSubtractOpExprDataObj *) ((ScXMLCoinSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLConstantDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *)  ((ScXMLConstantDataObj *) x));
}
static void *_p_ScXMLDivideOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLDivideOpExprDataObj *) x));
}
static void *_p_ScXMLEqualsOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *)  ((ScXMLExprDataObj *) x));
}
static void *_p_ScXMLInExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *)(ScXMLMinimumExprDataObj *) ((ScXMLInExprDataObj *) x));
}
static void *_p_ScXMLMinimumExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLMinimumExprDataObj *) x));
}
static void *_p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLNegateOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLNegateOpExprDataObj *) x));
}
static void *_p_ScXMLNotOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLNotOpExprDataObj *) x));
}
static void *_p_ScXMLOrOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLOrOpExprDataObj *) x));
}
static void *_p_ScXMLRealDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLConstantDataObj *) ((ScXMLRealDataObj *) x));
}
static void *_p_ScXMLReferenceDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLReferenceDataObj *) x));
}
static void *_p_ScXMLSbDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLConstantDataObj *) ((ScXMLSbDataObj *) x));
}
static void *_p_ScXMLStringDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLConstantDataObj *) ((ScXMLStringDataObj *) x));
}
static void *_p_ScXMLSubtractOpExprDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *) (ScXMLExprDataObj *) ((ScXMLSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLXMLDataObjTo_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj *)  ((ScXMLXMLDataObj *) x));
}
static void *_p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLDivideOpExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDivideOpExprDataObj *)  ((ScXMLCoinDivideOpExprDataObj *) x));
}
static void *_p_ScXMLAbstractStateEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLAbstractStateElt *) x));
}
static void *_p_ScXMLAnchorEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLAnchorElt *) x));
}
static void *_p_ScXMLAssignEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLAssignElt *) x));
}
static void *_p_ScXMLContentEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLContentElt *) x));
}
static void *_p_ScXMLDataEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLDataElt *) x));
}
static void *_p_ScXMLDataModelEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLDataModelElt *) x));
}
static void *_p_ScXMLElseEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLElseElt *) x));
}
static void *_p_ScXMLElseIfEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLElseIfElt *) x));
}
static void *_p_ScXMLEventEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLEventElt *) x));
}
static void *_p_ScXMLExecutableEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLExecutableElt *) x));
}
static void *_p_ScXMLFinalEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLAbstractStateElt *) ((ScXMLFinalElt *) x));
}
static void *_p_ScXMLFinalizeEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLFinalizeElt *) x));
}
static void *_p_ScXMLHistoryEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLHistoryElt *) x));
}
static void *_p_ScXMLIfEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLIfElt *) x));
}
static void *_p_ScXMLInitialEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLInitialElt *) x));
}
static void *_p_ScXMLInvokeEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLInvokeElt *) x));
}
static void *_p_ScXMLLogEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLLogElt *) x));
}
static void *_p_ScXMLOnEntryEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLOnEntryElt *) x));
}
static void *_p_ScXMLOnExitEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLOnExitElt *) x));
}
static void *_p_ScXMLParallelEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLAbstractStateElt *) ((ScXMLParallelElt *) x));
}
static void *_p_ScXMLParamEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLParamElt *) x));
}
static void *_p_ScXMLScriptEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLScriptElt *) x));
}
static void *_p_ScXMLScxmlEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLScxmlElt *) x));
}
static void *_p_ScXMLSendEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLSendElt *) x));
}
static void *_p_ScXMLStateEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLAbstractStateElt *) ((ScXMLStateElt *) x));
}
static void *_p_ScXMLTransitionEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *)  ((ScXMLTransitionElt *) x));
}
static void *_p_ScXMLValidateEltTo_p_ScXMLElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLElt *) (ScXMLExecutableElt *) ((ScXMLValidateElt *) x));
}
static void *_p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLEqualsOpExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEqualsOpExprDataObj *)  ((ScXMLCoinEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLCoinEvaluatorTo_p_ScXMLEvaluator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEvaluator *)  ((ScXMLCoinEvaluator *) x));
}
static void *_p_ScXMLECMAScriptEvaluatorTo_p_ScXMLEvaluator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEvaluator *)  ((ScXMLECMAScriptEvaluator *) x));
}
static void *_p_ScXMLMinimumEvaluatorTo_p_ScXMLEvaluator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEvaluator *)  ((ScXMLMinimumEvaluator *) x));
}
static void *_p_ScXMLXPathEvaluatorTo_p_ScXMLEvaluator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEvaluator *)  ((ScXMLXPathEvaluator *) x));
}
static void *_p_SoScXMLEventTo_p_ScXMLEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEvent *)  ((SoScXMLEvent *) x));
}
static void *_p_ScXMLStateMachineTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *)  ((ScXMLStateMachine *) x));
}
static void *_p_SoScXMLDollyTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLDollyTarget *) x));
}
static void *_p_SoScXMLFlightControlTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLFlightControlTarget *) x));
}
static void *_p_SoScXMLMiscTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLMiscTarget *) x));
}
static void *_p_SoScXMLMotionTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLMotionTarget *) x));
}
static void *_p_SoScXMLNavigationTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *)  ((SoScXMLNavigationTarget *) x));
}
static void *_p_SoScXMLPanTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLPanTarget *) x));
}
static void *_p_SoScXMLRotateTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLRotateTarget *) x));
}
static void *_p_SoScXMLSeekTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLSeekTarget *) x));
}
static void *_p_SoScXMLSpinTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLSpinTarget *) x));
}
static void *_p_SoScXMLStateMachineTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (ScXMLStateMachine *) ((SoScXMLStateMachine *) x));
}
static void *_p_SoScXMLZoomTargetTo_p_ScXMLEventTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLEventTarget *) (SoScXMLNavigationTarget *) ((SoScXMLZoomTarget *) x));
}
static void *_p_ScXMLAssignEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLAssignElt *) x));
}
static void *_p_ScXMLElseEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLElseElt *) x));
}
static void *_p_ScXMLElseIfEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLElseIfElt *) x));
}
static void *_p_ScXMLEventEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLEventElt *) x));
}
static void *_p_ScXMLIfEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLIfElt *) x));
}
static void *_p_ScXMLInvokeEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLInvokeElt *) x));
}
static void *_p_ScXMLLogEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLLogElt *) x));
}
static void *_p_ScXMLScriptEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLScriptElt *) x));
}
static void *_p_ScXMLSendEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLSendElt *) x));
}
static void *_p_ScXMLValidateEltTo_p_ScXMLExecutableElt(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExecutableElt *)  ((ScXMLValidateElt *) x));
}
static void *_p_ScXMLAddOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLAddOpExprDataObj *) x));
}
static void *_p_ScXMLAndOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLAndOpExprDataObj *) x));
}
static void *_p_ScXMLAppendOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLAppendOpExprDataObj *) x));
}
static void *_p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLAddOpExprDataObj *) ((ScXMLCoinAddOpExprDataObj *) x));
}
static void *_p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLDivideOpExprDataObj *) ((ScXMLCoinDivideOpExprDataObj *) x));
}
static void *_p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLEqualsOpExprDataObj *) ((ScXMLCoinEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLCoinLengthFuncExprDataObj *) x));
}
static void *_p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLMultiplyOpExprDataObj *) ((ScXMLCoinMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLSubtractOpExprDataObj *) ((ScXMLCoinSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLDivideOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLDivideOpExprDataObj *) x));
}
static void *_p_ScXMLEqualsOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLInExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *) (ScXMLMinimumExprDataObj *) ((ScXMLInExprDataObj *) x));
}
static void *_p_ScXMLMinimumExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLMinimumExprDataObj *) x));
}
static void *_p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLNegateOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLNegateOpExprDataObj *) x));
}
static void *_p_ScXMLNotOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLNotOpExprDataObj *) x));
}
static void *_p_ScXMLOrOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLOrOpExprDataObj *) x));
}
static void *_p_ScXMLReferenceDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLReferenceDataObj *) x));
}
static void *_p_ScXMLSubtractOpExprDataObjTo_p_ScXMLExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLExprDataObj *)  ((ScXMLSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLInExprDataObjTo_p_ScXMLMinimumExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLMinimumExprDataObj *)  ((ScXMLInExprDataObj *) x));
}
static void *_p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLMultiplyOpExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLMultiplyOpExprDataObj *)  ((ScXMLCoinMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLAbstractStateEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLAbstractStateElt *) x));
}
static void *_p_ScXMLAddOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLAddOpExprDataObj *) x));
}
static void *_p_ScXMLAnchorEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLAnchorElt *) x));
}
static void *_p_ScXMLAndOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLAndOpExprDataObj *) x));
}
static void *_p_ScXMLAppendOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLAppendOpExprDataObj *) x));
}
static void *_p_ScXMLAssignEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLAssignElt *) x));
}
static void *_p_ScXMLBoolDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLConstantDataObj *) ((ScXMLBoolDataObj *) x));
}
static void *_p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLAddOpExprDataObj *) ((ScXMLCoinAddOpExprDataObj *) x));
}
static void *_p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLDivideOpExprDataObj *) ((ScXMLCoinDivideOpExprDataObj *) x));
}
static void *_p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLEqualsOpExprDataObj *) ((ScXMLCoinEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLCoinEvaluatorTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEvaluator *) ((ScXMLCoinEvaluator *) x));
}
static void *_p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLCoinLengthFuncExprDataObj *) x));
}
static void *_p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLMultiplyOpExprDataObj *) ((ScXMLCoinMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLSubtractOpExprDataObj *) ((ScXMLCoinSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLConstantDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *) ((ScXMLConstantDataObj *) x));
}
static void *_p_ScXMLContentEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLContentElt *) x));
}
static void *_p_ScXMLDataEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLDataElt *) x));
}
static void *_p_ScXMLDataModelEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLDataModelElt *) x));
}
static void *_p_ScXMLDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLDataObj *) x));
}
static void *_p_ScXMLDivideOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLDivideOpExprDataObj *) x));
}
static void *_p_ScXMLDocumentTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLDocument *) x));
}
static void *_p_ScXMLECMAScriptEvaluatorTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEvaluator *) ((ScXMLECMAScriptEvaluator *) x));
}
static void *_p_ScXMLElseEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLElseElt *) x));
}
static void *_p_ScXMLElseIfEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLElseIfElt *) x));
}
static void *_p_ScXMLEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLElt *) x));
}
static void *_p_ScXMLEqualsOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLEqualsOpExprDataObj *) x));
}
static void *_p_ScXMLEvaluatorTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLEvaluator *) x));
}
static void *_p_ScXMLEventTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLEvent *) x));
}
static void *_p_ScXMLEventEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLEventElt *) x));
}
static void *_p_ScXMLEventTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *)  ((ScXMLEventTarget *) x));
}
static void *_p_ScXMLExecutableEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLExecutableElt *) x));
}
static void *_p_ScXMLExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *) ((ScXMLExprDataObj *) x));
}
static void *_p_ScXMLFinalEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLAbstractStateElt *) ((ScXMLFinalElt *) x));
}
static void *_p_ScXMLFinalizeEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLFinalizeElt *) x));
}
static void *_p_ScXMLHistoryEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLHistoryElt *) x));
}
static void *_p_ScXMLIfEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLIfElt *) x));
}
static void *_p_ScXMLInExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *)(ScXMLMinimumExprDataObj *) ((ScXMLInExprDataObj *) x));
}
static void *_p_ScXMLInitialEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLInitialElt *) x));
}
static void *_p_ScXMLInvokeEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLInvokeElt *) x));
}
static void *_p_ScXMLLogEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLLogElt *) x));
}
static void *_p_ScXMLMinimumEvaluatorTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEvaluator *) ((ScXMLMinimumEvaluator *) x));
}
static void *_p_ScXMLMinimumExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLMinimumExprDataObj *) x));
}
static void *_p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLMultiplyOpExprDataObj *) x));
}
static void *_p_ScXMLNegateOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLNegateOpExprDataObj *) x));
}
static void *_p_ScXMLNotOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLNotOpExprDataObj *) x));
}
static void *_p_ScXMLOnEntryEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLOnEntryElt *) x));
}
static void *_p_ScXMLOnExitEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLOnExitElt *) x));
}
static void *_p_ScXMLOrOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLOrOpExprDataObj *) x));
}
static void *_p_ScXMLParallelEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLAbstractStateElt *) ((ScXMLParallelElt *) x));
}
static void *_p_ScXMLParamEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLParamElt *) x));
}
static void *_p_ScXMLRealDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLConstantDataObj *) ((ScXMLRealDataObj *) x));
}
static void *_p_ScXMLReferenceDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLReferenceDataObj *) x));
}
static void *_p_ScXMLSbDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLConstantDataObj *) ((ScXMLSbDataObj *) x));
}
static void *_p_ScXMLScriptEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLScriptElt *) x));
}
static void *_p_ScXMLScxmlEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLScxmlElt *) x));
}
static void *_p_ScXMLSendEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLSendElt *) x));
}
static void *_p_ScXMLStateEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLAbstractStateElt *) ((ScXMLStateElt *) x));
}
static void *_p_ScXMLStateMachineTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *) ((ScXMLStateMachine *) x));
}
static void *_p_ScXMLStringDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLConstantDataObj *) ((ScXMLStringDataObj *) x));
}
static void *_p_ScXMLSubtractOpExprDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *)(ScXMLExprDataObj *) ((ScXMLSubtractOpExprDataObj *) x));
}
static void *_p_ScXMLTransitionEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *) ((ScXMLTransitionElt *) x));
}
static void *_p_ScXMLValidateEltTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLElt *)(ScXMLExecutableElt *) ((ScXMLValidateElt *) x));
}
static void *_p_ScXMLXMLDataObjTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLDataObj *) ((ScXMLXMLDataObj *) x));
}
static void *_p_ScXMLXPathEvaluatorTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEvaluator *) ((ScXMLXPathEvaluator *) x));
}
static void *_p_SoScXMLDollyTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLDollyTarget *) x));
}
static void *_p_SoScXMLEventTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEvent *) ((SoScXMLEvent *) x));
}
static void *_p_SoScXMLFlightControlTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLFlightControlTarget *) x));
}
static void *_p_SoScXMLMiscTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLMiscTarget *) x));
}
static void *_p_SoScXMLMotionTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLMotionTarget *) x));
}
static void *_p_SoScXMLNavigationTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *) ((SoScXMLNavigationTarget *) x));
}
static void *_p_SoScXMLPanTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLPanTarget *) x));
}
static void *_p_SoScXMLRotateTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLRotateTarget *) x));
}
static void *_p_SoScXMLSeekTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLSeekTarget *) x));
}
static void *_p_SoScXMLSpinTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLSpinTarget *) x));
}
static void *_p_SoScXMLStateMachineTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(ScXMLStateMachine *) ((SoScXMLStateMachine *) x));
}
static void *_p_SoScXMLZoomTargetTo_p_ScXMLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLObject *) (ScXMLEventTarget *)(SoScXMLNavigationTarget *) ((SoScXMLZoomTarget *) x));
}
static void *_p_SoScXMLStateMachineTo_p_ScXMLStateMachine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLStateMachine *)  ((SoScXMLStateMachine *) x));
}
static void *_p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLSubtractOpExprDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLSubtractOpExprDataObj *)  ((ScXMLCoinSubtractOpExprDataObj *) x));
}
static void *_p_SoBBoxModelMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *) (SoModelMatrixElement *) ((SoBBoxModelMatrixElement *) x));
}
static void *_p_SoBumpMapMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoBumpMapMatrixElement *) x));
}
static void *_p_SoClipPlaneElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoClipPlaneElement *) x));
}
static void *_p_SoGLClipPlaneElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *) (SoClipPlaneElement *) ((SoGLClipPlaneElement *) x));
}
static void *_p_SoGLModelMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *) (SoModelMatrixElement *) ((SoGLModelMatrixElement *) x));
}
static void *_p_SoGLMultiTextureMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *) (SoMultiTextureMatrixElement *) ((SoGLMultiTextureMatrixElement *) x));
}
static void *_p_SoGLVertexAttributeElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *) (SoVertexAttributeElement *) ((SoGLVertexAttributeElement *) x));
}
static void *_p_SoLightElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoLightElement *) x));
}
static void *_p_SoModelMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoModelMatrixElement *) x));
}
static void *_p_SoMultiTextureMatrixElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoMultiTextureMatrixElement *) x));
}
static void *_p_SoProfileElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoProfileElement *) x));
}
static void *_p_SoVertexAttributeElementTo_p_SoAccumulatedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAccumulatedElement *)  ((SoVertexAttributeElement *) x));
}
static void *_p_SoAudioRenderActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoAudioRenderAction *) x));
}
static void *_p_SoBoxHighlightRenderActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoGLRenderAction *) ((SoBoxHighlightRenderAction *) x));
}
static void *_p_SoCallbackActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoCallbackAction *) x));
}
static void *_p_SoGLRenderActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoGLRenderAction *) x));
}
static void *_p_SoGetBoundingBoxActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoGetBoundingBoxAction *) x));
}
static void *_p_SoGetMatrixActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoGetMatrixAction *) x));
}
static void *_p_SoGetPrimitiveCountActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoGetPrimitiveCountAction *) x));
}
static void *_p_SoHandleEventActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoHandleEventAction *) x));
}
static void *_p_SoIntersectionDetectionActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoIntersectionDetectionAction *) x));
}
static void *_p_SoLineHighlightRenderActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoGLRenderAction *) ((SoLineHighlightRenderAction *) x));
}
static void *_p_SoPickActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoPickAction *) x));
}
static void *_p_SoRayPickActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoPickAction *) ((SoRayPickAction *) x));
}
static void *_p_SoReorganizeActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoSimplifyAction *) ((SoReorganizeAction *) x));
}
static void *_p_SoSearchActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoSearchAction *) x));
}
static void *_p_SoSimplifyActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoSimplifyAction *) x));
}
static void *_p_SoToVRML2ActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoToVRMLAction *) ((SoToVRML2Action *) x));
}
static void *_p_SoToVRMLActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoToVRMLAction *) x));
}
static void *_p_SoVectorizeActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoCallbackAction *) ((SoVectorizeAction *) x));
}
static void *_p_SoVectorizePSActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *) (SoCallbackAction *)(SoVectorizeAction *) ((SoVectorizePSAction *) x));
}
static void *_p_SoWriteActionTo_p_SoAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoAction *)  ((SoWriteAction *) x));
}
static void *_p_SoAlphaTestTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoAlphaTest *) x));
}
static void *_p_SoAnnotationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoAnnotation *) x));
}
static void *_p_SoAntiSquishTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoAntiSquish *) x));
}
static void *_p_SoAppearanceKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoAppearanceKit *) x));
}
static void *_p_SoArrayTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoArray *) x));
}
static void *_p_SoAsciiTextTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoAsciiText *) x));
}
static void *_p_SoBaseColorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoBaseColor *) x));
}
static void *_p_SoBaseKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoBaseKit *) x));
}
static void *_p_SoBlinkerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSwitch *) ((SoBlinker *) x));
}
static void *_p_SoBoolOperationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoBoolOperation *) x));
}
static void *_p_SoBumpMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoBumpMap *) x));
}
static void *_p_SoBumpMapCoordinateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoBumpMapCoordinate *) x));
}
static void *_p_SoBumpMapTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoBumpMapTransform *) x));
}
static void *_p_SoCacheHintTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoCacheHint *) x));
}
static void *_p_SoCalculatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoCalculator *) x));
}
static void *_p_SoCallbackTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoCallback *) x));
}
static void *_p_SoCameraTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoCamera *) x));
}
static void *_p_SoCameraKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoCameraKit *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoCenterballDragger *) x));
}
static void *_p_SoCenterballManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoCenterballManip *) x));
}
static void *_p_SoClipPlaneTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoClipPlane *) x));
}
static void *_p_SoClipPlaneManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoClipPlane *) ((SoClipPlaneManip *) x));
}
static void *_p_SoColorIndexTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoColorIndex *) x));
}
static void *_p_SoComplexityTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoComplexity *) x));
}
static void *_p_SoComposeMatrixTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeMatrix *) x));
}
static void *_p_SoComposeRotationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeRotation *) x));
}
static void *_p_SoComposeRotationFromToTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeRotationFromTo *) x));
}
static void *_p_SoComposeVec2fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeVec2f *) x));
}
static void *_p_SoComposeVec3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeVec3f *) x));
}
static void *_p_SoComposeVec4fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComposeVec4f *) x));
}
static void *_p_SoComputeBoundingBoxTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoComputeBoundingBox *) x));
}
static void *_p_SoConcatenateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoConcatenate *) x));
}
static void *_p_SoConeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCone *) x));
}
static void *_p_SoCoordinate3To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoCoordinate3 *) x));
}
static void *_p_SoCoordinate4To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoCoordinate4 *) x));
}
static void *_p_SoCounterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoCounter *) x));
}
static void *_p_SoCubeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCube *) x));
}
static void *_p_SoCylinderTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCylinder *) x));
}
static void *_p_SoDecomposeMatrixTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoDecomposeMatrix *) x));
}
static void *_p_SoDecomposeRotationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoDecomposeRotation *) x));
}
static void *_p_SoDecomposeVec2fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec2f *) x));
}
static void *_p_SoDecomposeVec3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec3f *) x));
}
static void *_p_SoDecomposeVec4fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec4f *) x));
}
static void *_p_SoDepthBufferTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoDepthBuffer *) x));
}
static void *_p_SoDirectionalLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoDirectionalLight *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDirectionalLightManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *)(SoDirectionalLight *) ((SoDirectionalLightManip *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDragPointDragger *) x));
}
static void *_p_SoDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *) ((SoDragger *) x));
}
static void *_p_SoDrawStyleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoDrawStyle *) x));
}
static void *_p_SoElapsedTimeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoElapsedTime *) x));
}
static void *_p_SoEngineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *) ((SoEngine *) x));
}
static void *_p_SoEnvironmentTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoEnvironment *) x));
}
static void *_p_SoEventCallbackTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoEventCallback *) x));
}
static void *_p_SoExtSelectionTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *)(SoSelection *) ((SoExtSelection *) x));
}
static void *_p_SoFaceSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet *) x));
}
static void *_p_SoFieldContainerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *)  ((SoFieldContainer *) x));
}
static void *_p_SoFieldConverterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoFieldConverter *) x));
}
static void *_p_SoFileTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoFile *) x));
}
static void *_p_SoFontTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoFont *) x));
}
static void *_p_SoFontStyleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoFont *) ((SoFontStyle *) x));
}
static void *_p_SoFragmentShaderTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderObject *) ((SoFragmentShader *) x));
}
static void *_p_SoFrustumCameraTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoFrustumCamera *) x));
}
static void *_p_SoFullPathTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoPath *) ((SoFullPath *) x));
}
static void *_p_SoGateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoGate *) x));
}
static void *_p_SoGeoCoordinateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoGeoCoordinate *) x));
}
static void *_p_SoGeoLocationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoGeoLocation *) x));
}
static void *_p_SoGeoOriginTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoGeoOrigin *) x));
}
static void *_p_SoGeoSeparatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoGeoSeparator *) x));
}
static void *_p_SoGroupTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoGroup *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoHandleBoxManip *) x));
}
static void *_p_SoHeightMapToNormalMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoTexture2Convert *) ((SoHeightMapToNormalMap *) x));
}
static void *_p_SoImageTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoImage *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedNurbsCurveTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoIndexedNurbsCurve *) x));
}
static void *_p_SoIndexedNurbsSurfaceTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoIndexedNurbsSurface *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *) ((SoIndexedShape *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoInfoTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoInfo *) x));
}
static void *_p_SoInteractionKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoInteractionKit *) x));
}
static void *_p_SoInterpolateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoInterpolate *) x));
}
static void *_p_SoInterpolateFloatTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateFloat *) x));
}
static void *_p_SoInterpolateRotationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateRotation *) x));
}
static void *_p_SoInterpolateVec2fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec2f *) x));
}
static void *_p_SoInterpolateVec3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec3f *) x));
}
static void *_p_SoInterpolateVec4fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec4f *) x));
}
static void *_p_SoJackDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoJackDragger *) x));
}
static void *_p_SoJackManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoJackManip *) x));
}
static void *_p_SoLODTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoLOD *) x));
}
static void *_p_SoLabelTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoLabel *) x));
}
static void *_p_SoLevelOfDetailTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoLevelOfDetail *) x));
}
static void *_p_SoLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoLight *) x));
}
static void *_p_SoLightKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoLightKit *) x));
}
static void *_p_SoLightModelTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoLightModel *) x));
}
static void *_p_SoLineSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet *) x));
}
static void *_p_SoLinearProfileTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoProfile *) ((SoLinearProfile *) x));
}
static void *_p_SoListenerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoListener *) x));
}
static void *_p_SoLocateHighlightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoLocateHighlight *) x));
}
static void *_p_SoMarkerSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoMaterialTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoMaterial *) x));
}
static void *_p_SoMaterialBindingTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoMaterialBinding *) x));
}
static void *_p_SoMatrixTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoMatrixTransform *) x));
}
static void *_p_SoMultipleCopyTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoMultipleCopy *) x));
}
static void *_p_SoNodeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *) ((SoNode *) x));
}
static void *_p_SoNodeEngineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoNodeEngine *) x));
}
static void *_p_SoNodeKitListPartTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoNodeKitListPart *) x));
}
static void *_p_SoNodeKitPathTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoPath *) ((SoNodeKitPath *) x));
}
static void *_p_SoNonIndexedShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *) ((SoNonIndexedShape *) x));
}
static void *_p_SoNormalTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoNormal *) x));
}
static void *_p_SoNormalBindingTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoNormalBinding *) x));
}
static void *_p_SoNurbsCurveTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoNurbsCurve *) x));
}
static void *_p_SoNurbsProfileTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoProfile *) ((SoNurbsProfile *) x));
}
static void *_p_SoNurbsSurfaceTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoNurbsSurface *) x));
}
static void *_p_SoOnOffTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoOnOff *) x));
}
static void *_p_SoOneShotTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoOneShot *) x));
}
static void *_p_SoOrthographicCameraTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoOrthographicCamera *) x));
}
static void *_p_SoPackedColorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoPackedColor *) x));
}
static void *_p_SoPathTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *)  ((SoPath *) x));
}
static void *_p_SoPathSwitchTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoPathSwitch *) x));
}
static void *_p_SoPendulumTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoRotation *) ((SoPendulum *) x));
}
static void *_p_SoPerspectiveCameraTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoPerspectiveCamera *) x));
}
static void *_p_SoPickStyleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoPickStyle *) x));
}
static void *_p_SoPointLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoPointLight *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoPointLightDragger *) x));
}
static void *_p_SoPointLightManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *)(SoPointLight *) ((SoPointLightManip *) x));
}
static void *_p_SoPointSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet *) x));
}
static void *_p_SoPolygonOffsetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoPolygonOffset *) x));
}
static void *_p_SoProfileTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoProfile *) x));
}
static void *_p_SoProfileCoordinate2To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoProfileCoordinate2 *) x));
}
static void *_p_SoProfileCoordinate3To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoProfileCoordinate3 *) x));
}
static void *_p_SoProtoTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoProto *) x));
}
static void *_p_SoProtoInstanceTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoProtoInstance *) x));
}
static void *_p_SoQuadMeshTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh *) x));
}
static void *_p_SoResetTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoResetTransform *) x));
}
static void *_p_SoReversePerspectiveCameraTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoCamera *)(SoPerspectiveCamera *) ((SoReversePerspectiveCamera *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger *) x));
}
static void *_p_SoRotationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoRotation *) x));
}
static void *_p_SoRotationXYZTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoRotationXYZ *) x));
}
static void *_p_SoRotorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoRotation *) ((SoRotor *) x));
}
static void *_p_SoScaleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoScale *) x));
}
static void *_p_SoScale1DraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger *) x));
}
static void *_p_SoSceneKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoSceneKit *) x));
}
static void *_p_SoSceneTexture2To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoSceneTexture2 *) x));
}
static void *_p_SoSceneTextureCubeMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoSceneTextureCubeMap *) x));
}
static void *_p_SoSelectOneTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoSelectOne *) x));
}
static void *_p_SoSelectionTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoSelection *) x));
}
static void *_p_SoSeparatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoSeparator *) x));
}
static void *_p_SoSeparatorKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoSeparatorKit *) x));
}
static void *_p_SoShaderObjectTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoShaderObject *) x));
}
static void *_p_SoShaderParameterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoShaderParameter *) x));
}
static void *_p_SoShaderParameter1fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1f *) x));
}
static void *_p_SoShaderParameter1iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1i *) x));
}
static void *_p_SoShaderParameter2fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2f *) x));
}
static void *_p_SoShaderParameter2iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2i *) x));
}
static void *_p_SoShaderParameter3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3f *) x));
}
static void *_p_SoShaderParameter3iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3i *) x));
}
static void *_p_SoShaderParameter4fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4f *) x));
}
static void *_p_SoShaderParameter4iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4i *) x));
}
static void *_p_SoShaderParameterArray1fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1f *) x));
}
static void *_p_SoShaderParameterArray1iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1i *) x));
}
static void *_p_SoShaderParameterArray2fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2f *) x));
}
static void *_p_SoShaderParameterArray2iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2i *) x));
}
static void *_p_SoShaderParameterArray3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3f *) x));
}
static void *_p_SoShaderParameterArray3iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3i *) x));
}
static void *_p_SoShaderParameterArray4fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4f *) x));
}
static void *_p_SoShaderParameterArray4iTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4i *) x));
}
static void *_p_SoShaderParameterMatrixTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrix *) x));
}
static void *_p_SoShaderParameterMatrixArrayTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrixArray *) x));
}
static void *_p_SoShaderProgramTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoShaderProgram *) x));
}
static void *_p_SoShaderStateMatrixParameterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderStateMatrixParameter *) x));
}
static void *_p_SoShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoShape *) x));
}
static void *_p_SoShapeHintsTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoShapeHints *) x));
}
static void *_p_SoShapeKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoShapeKit *) x));
}
static void *_p_SoShuttleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTranslation *) ((SoShuttle *) x));
}
static void *_p_SoSphereTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoSphere *) x));
}
static void *_p_SoSpotLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoSpotLight *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger *) x));
}
static void *_p_SoSpotLightManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoLight *)(SoSpotLight *) ((SoSpotLightManip *) x));
}
static void *_p_SoSurroundScaleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoSurroundScale *) x));
}
static void *_p_SoSwitchTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoSwitch *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger *) x));
}
static void *_p_SoTabBoxManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTabBoxManip *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger *) x));
}
static void *_p_SoTempPathTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoPath *)(SoFullPath *) ((SoTempPath *) x));
}
static void *_p_SoText2To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoText2 *) x));
}
static void *_p_SoText3To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoText3 *) x));
}
static void *_p_SoTextureTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTexture *) x));
}
static void *_p_SoTexture2To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTexture2 *) x));
}
static void *_p_SoTexture2ConvertTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoTexture2Convert *) x));
}
static void *_p_SoTexture2TransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTexture2Transform *) x));
}
static void *_p_SoTexture3To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTexture3 *) x));
}
static void *_p_SoTexture3TransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTexture3Transform *) x));
}
static void *_p_SoTextureCombineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCombine *) x));
}
static void *_p_SoTextureCoordinate2To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinate2 *) x));
}
static void *_p_SoTextureCoordinate3To_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinate3 *) x));
}
static void *_p_SoTextureCoordinateBindingTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateBinding *) x));
}
static void *_p_SoTextureCoordinateCubeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateCube *) x));
}
static void *_p_SoTextureCoordinateCylinderTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateCylinder *) x));
}
static void *_p_SoTextureCoordinateDefaultTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateDefault *) x));
}
static void *_p_SoTextureCoordinateEnvironmentTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateEnvironment *) x));
}
static void *_p_SoTextureCoordinateFunctionTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateFunction *) x));
}
static void *_p_SoTextureCoordinateNormalMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateNormalMap *) x));
}
static void *_p_SoTextureCoordinateObjectTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateObject *) x));
}
static void *_p_SoTextureCoordinatePlaneTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinatePlane *) x));
}
static void *_p_SoTextureCoordinateReflectionMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateReflectionMap *) x));
}
static void *_p_SoTextureCoordinateSphereTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateSphere *) x));
}
static void *_p_SoTextureCubeMapTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTextureCubeMap *) x));
}
static void *_p_SoTextureMatrixTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureMatrixTransform *) x));
}
static void *_p_SoTextureScalePolicyTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureScalePolicy *) x));
}
static void *_p_SoTextureUnitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTextureUnit *) x));
}
static void *_p_SoTimeCounterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoTimeCounter *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTrackballDragger *) x));
}
static void *_p_SoTrackballManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTrackballManip *) x));
}
static void *_p_SoTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoTransform *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *) ((SoTransformManip *) x));
}
static void *_p_SoTransformSeparatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoTransformSeparator *) x));
}
static void *_p_SoTransformVec3fTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoTransformVec3f *) x));
}
static void *_p_SoTransformationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTransformation *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformerDragger *) x));
}
static void *_p_SoTransformerManipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformerManip *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger *) x));
}
static void *_p_SoTranslationTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoTranslation *) x));
}
static void *_p_SoTransparencyTypeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoTransparencyType *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet *) x));
}
static void *_p_SoTriggerAnyTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoEngine *) ((SoTriggerAny *) x));
}
static void *_p_SoUniformShaderParameterTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderParameter *) ((SoUniformShaderParameter *) x));
}
static void *_p_SoUnitsTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoUnits *) x));
}
static void *_p_SoVRMLAnchorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLAnchor *) x));
}
static void *_p_SoVRMLAppearanceTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLAppearance *) x));
}
static void *_p_SoVRMLAudioClipTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLAudioClip *) x));
}
static void *_p_SoVRMLBackgroundTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLBackground *) x));
}
static void *_p_SoVRMLBillboardTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLBillboard *) x));
}
static void *_p_SoVRMLBoxTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLBox *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLColorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLColor *) x));
}
static void *_p_SoVRMLColorInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLColorInterpolator *) x));
}
static void *_p_SoVRMLConeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCone *) x));
}
static void *_p_SoVRMLCoordinateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLCoordinate *) x));
}
static void *_p_SoVRMLCoordinateInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator *) x));
}
static void *_p_SoVRMLCylinderTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCylinder *) x));
}
static void *_p_SoVRMLCylinderSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLCylinderSensor *) x));
}
static void *_p_SoVRMLDirectionalLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLDirectionalLight *) x));
}
static void *_p_SoVRMLDragSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *) ((SoVRMLDragSensor *) x));
}
static void *_p_SoVRMLElevationGridTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLElevationGrid *) x));
}
static void *_p_SoVRMLExtrusionTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLExtrusion *) x));
}
static void *_p_SoVRMLFogTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLFog *) x));
}
static void *_p_SoVRMLFontStyleTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLFontStyle *) x));
}
static void *_p_SoVRMLGeometryTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoVRMLGeometry *) x));
}
static void *_p_SoVRMLGroupTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLGroup *) x));
}
static void *_p_SoVRMLImageTextureTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLImageTexture *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape *) x));
}
static void *_p_SoVRMLInlineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLInline *) x));
}
static void *_p_SoVRMLInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *) ((SoVRMLInterpolator *) x));
}
static void *_p_SoVRMLLODTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLLOD *) x));
}
static void *_p_SoVRMLLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLLight *) x));
}
static void *_p_SoVRMLMaterialTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLMaterial *) x));
}
static void *_p_SoVRMLMovieTextureTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLMovieTexture *) x));
}
static void *_p_SoVRMLNavigationInfoTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLNavigationInfo *) x));
}
static void *_p_SoVRMLNormalTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLNormal *) x));
}
static void *_p_SoVRMLNormalInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLNormalInterpolator *) x));
}
static void *_p_SoVRMLOrientationInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator *) x));
}
static void *_p_SoVRMLParentTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLParent *) x));
}
static void *_p_SoVRMLPixelTextureTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLPixelTexture *) x));
}
static void *_p_SoVRMLPlaneSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLPlaneSensor *) x));
}
static void *_p_SoVRMLPointLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLPointLight *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLPositionInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLPositionInterpolator *) x));
}
static void *_p_SoVRMLProximitySensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLProximitySensor *) x));
}
static void *_p_SoVRMLScalarInterpolatorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLScalarInterpolator *) x));
}
static void *_p_SoVRMLScriptTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLScript *) x));
}
static void *_p_SoVRMLSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLSensor *) x));
}
static void *_p_SoVRMLShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLShape *) x));
}
static void *_p_SoVRMLSoundTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLSound *) x));
}
static void *_p_SoVRMLSphereTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLSphere *) x));
}
static void *_p_SoVRMLSphereSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLSphereSensor *) x));
}
static void *_p_SoVRMLSpotLightTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLSpotLight *) x));
}
static void *_p_SoVRMLSwitchTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLSwitch *) x));
}
static void *_p_SoVRMLTextTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLText *) x));
}
static void *_p_SoVRMLTextureTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLTexture *) x));
}
static void *_p_SoVRMLTextureCoordinateTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLTextureCoordinate *) x));
}
static void *_p_SoVRMLTextureTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLTextureTransform *) x));
}
static void *_p_SoVRMLTimeSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoNodeEngine *) ((SoVRMLTimeSensor *) x));
}
static void *_p_SoVRMLTouchSensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLTouchSensor *) x));
}
static void *_p_SoVRMLTransformTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform *) x));
}
static void *_p_SoVRMLVertexLineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexLine *) x));
}
static void *_p_SoVRMLVertexPointTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexPoint *) x));
}
static void *_p_SoVRMLVertexShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexShape *) x));
}
static void *_p_SoVRMLViewpointTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLViewpoint *) x));
}
static void *_p_SoVRMLVisibilitySensorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLVisibilitySensor *) x));
}
static void *_p_SoVRMLWorldInfoTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVRMLWorldInfo *) x));
}
static void *_p_SoVertexAttributeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVertexAttribute *) x));
}
static void *_p_SoVertexAttributeBindingTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVertexAttributeBinding *) x));
}
static void *_p_SoVertexPropertyTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoVertexProperty *) x));
}
static void *_p_SoVertexShaderTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShaderObject *) ((SoVertexShader *) x));
}
static void *_p_SoVertexShapeTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoVertexShape *) x));
}
static void *_p_SoWWWAnchorTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor *) x));
}
static void *_p_SoWWWInlineTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *) ((SoWWWInline *) x));
}
static void *_p_SoWrapperKitTo_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase *) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoWrapperKit *) x));
}
static void *_p_SoAppearanceKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoAppearanceKit *) x));
}
static void *_p_SoCameraKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoCameraKit *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoCenterballDragger *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoDragPointDragger *) x));
}
static void *_p_SoDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *) ((SoDragger *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger *) x));
}
static void *_p_SoInteractionKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoInteractionKit *) x));
}
static void *_p_SoJackDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoJackDragger *) x));
}
static void *_p_SoLightKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoLightKit *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoPointLightDragger *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger *) x));
}
static void *_p_SoScale1DraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger *) x));
}
static void *_p_SoSceneKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoSceneKit *) x));
}
static void *_p_SoSeparatorKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *)  ((SoSeparatorKit *) x));
}
static void *_p_SoShapeKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoSeparatorKit *) ((SoShapeKit *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTrackballDragger *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTransformerDragger *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger *) x));
}
static void *_p_SoWrapperKitTo_p_SoBaseKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseKit *) (SoSeparatorKit *) ((SoWrapperKit *) x));
}
static void *_p_SoChildListTo_p_SoBaseList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseList *) (SoNodeList *) ((SoChildList *) x));
}
static void *_p_SoEngineListTo_p_SoBaseList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseList *)  ((SoEngineList *) x));
}
static void *_p_SoNodeListTo_p_SoBaseList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseList *)  ((SoNodeList *) x));
}
static void *_p_SoPathListTo_p_SoBaseList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBaseList *)  ((SoPathList *) x));
}
static void *_p_SoMaterialBundleTo_p_SoBundle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBundle *)  ((SoMaterialBundle *) x));
}
static void *_p_SoNormalBundleTo_p_SoBundle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBundle *)  ((SoNormalBundle *) x));
}
static void *_p_SoTextureCoordinateBundleTo_p_SoBundle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBundle *)  ((SoTextureCoordinateBundle *) x));
}
static void *_p_SoKeyboardEventTo_p_SoButtonEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoButtonEvent *)  ((SoKeyboardEvent *) x));
}
static void *_p_SoMouseButtonEventTo_p_SoButtonEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoButtonEvent *)  ((SoMouseButtonEvent *) x));
}
static void *_p_SoSpaceballButtonEventTo_p_SoButtonEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoButtonEvent *)  ((SoSpaceballButtonEvent *) x));
}
static void *_p_SoBoundingBoxCacheTo_p_SoCache(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCache *)  ((SoBoundingBoxCache *) x));
}
static void *_p_SoConvexDataCacheTo_p_SoCache(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCache *)  ((SoConvexDataCache *) x));
}
static void *_p_SoGLRenderCacheTo_p_SoCache(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCache *)  ((SoGLRenderCache *) x));
}
static void *_p_SoNormalCacheTo_p_SoCache(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCache *)  ((SoNormalCache *) x));
}
static void *_p_SoTextureCoordinateCacheTo_p_SoCache(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCache *)  ((SoTextureCoordinateCache *) x));
}
static void *_p_SoVectorizeActionTo_p_SoCallbackAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCallbackAction *)  ((SoVectorizeAction *) x));
}
static void *_p_SoVectorizePSActionTo_p_SoCallbackAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCallbackAction *) (SoVectorizeAction *) ((SoVectorizePSAction *) x));
}
static void *_p_SoFrustumCameraTo_p_SoCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCamera *)  ((SoFrustumCamera *) x));
}
static void *_p_SoOrthographicCameraTo_p_SoCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCamera *)  ((SoOrthographicCamera *) x));
}
static void *_p_SoPerspectiveCameraTo_p_SoCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCamera *)  ((SoPerspectiveCamera *) x));
}
static void *_p_SoReversePerspectiveCameraTo_p_SoCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCamera *) (SoPerspectiveCamera *) ((SoReversePerspectiveCamera *) x));
}
static void *_p_SoClipPlaneManipTo_p_SoClipPlane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoClipPlane *)  ((SoClipPlaneManip *) x));
}
static void *_p_SoGLClipPlaneElementTo_p_SoClipPlaneElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoClipPlaneElement *)  ((SoGLClipPlaneElement *) x));
}
static void *_p_SoGLCoordinateElementTo_p_SoCoordinateElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoCoordinateElement *)  ((SoGLCoordinateElement *) x));
}
static void *_p_SoFieldSensorTo_p_SoDataSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDataSensor *)  ((SoFieldSensor *) x));
}
static void *_p_SoNodeSensorTo_p_SoDataSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDataSensor *)  ((SoNodeSensor *) x));
}
static void *_p_SoPathSensorTo_p_SoDataSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDataSensor *)  ((SoPathSensor *) x));
}
static void *_p_SoDataSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *)  ((SoDataSensor *) x));
}
static void *_p_SoFieldSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *) (SoDataSensor *) ((SoFieldSensor *) x));
}
static void *_p_SoIdleSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *)  ((SoIdleSensor *) x));
}
static void *_p_SoNodeSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *) (SoDataSensor *) ((SoNodeSensor *) x));
}
static void *_p_SoOneShotSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *)  ((SoOneShotSensor *) x));
}
static void *_p_SoPathSensorTo_p_SoDelayQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDelayQueueSensor *) (SoDataSensor *) ((SoPathSensor *) x));
}
static void *_p_SoGLDepthBufferElementTo_p_SoDepthBufferElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDepthBufferElement *)  ((SoGLDepthBufferElement *) x));
}
static void *_p_SoConeDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoConeDetail *) x));
}
static void *_p_SoCubeDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoCubeDetail *) x));
}
static void *_p_SoCylinderDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoCylinderDetail *) x));
}
static void *_p_SoFaceDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoFaceDetail *) x));
}
static void *_p_SoLineDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoLineDetail *) x));
}
static void *_p_SoNodeKitDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoNodeKitDetail *) x));
}
static void *_p_SoPointDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoPointDetail *) x));
}
static void *_p_SoTextDetailTo_p_SoDetail(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDetail *)  ((SoTextDetail *) x));
}
static void *_p_SoDirectionalLightManipTo_p_SoDirectionalLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDirectionalLight *)  ((SoDirectionalLightManip *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoCenterballDragger *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoDragPointDragger *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoHandleBoxDragger *) x));
}
static void *_p_SoJackDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoJackDragger *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoPointLightDragger *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoRotateSphericalDragger *) x));
}
static void *_p_SoScale1DraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoScaleUniformDragger *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoSpotLightDragger *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTabBoxDragger *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTabPlaneDragger *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTrackballDragger *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTransformerDragger *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoDragger(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDragger *)  ((SoTranslate2Dragger *) x));
}
static void *_p_SoGLDrawStyleElementTo_p_SoDrawStyleElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDrawStyleElement *)  ((SoGLDrawStyleElement *) x));
}
static void *_p_SoAccumulatedElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoAccumulatedElement *) x));
}
static void *_p_SoAmbientColorElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoAmbientColorElement *) x));
}
static void *_p_SoAnnoText3CharOrientElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoAnnoText3CharOrientElement *) x));
}
static void *_p_SoAnnoText3FontSizeHintElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoAnnoText3FontSizeHintElement *) x));
}
static void *_p_SoAnnoText3RenderPrintElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoAnnoText3RenderPrintElement *) x));
}
static void *_p_SoBBoxModelMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *)(SoModelMatrixElement *) ((SoBBoxModelMatrixElement *) x));
}
static void *_p_SoBumpMapCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoBumpMapCoordinateElement *) x));
}
static void *_p_SoBumpMapElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoBumpMapElement *) x));
}
static void *_p_SoBumpMapMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoBumpMapMatrixElement *) x));
}
static void *_p_SoCacheElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoCacheElement *) x));
}
static void *_p_SoCacheHintElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoCacheHintElement *) x));
}
static void *_p_SoClipPlaneElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoClipPlaneElement *) x));
}
static void *_p_SoComplexityElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoComplexityElement *) x));
}
static void *_p_SoComplexityTypeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoComplexityTypeElement *) x));
}
static void *_p_SoCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoCoordinateElement *) x));
}
static void *_p_SoCreaseAngleElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoCreaseAngleElement *) x));
}
static void *_p_SoCullElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoCullElement *) x));
}
static void *_p_SoDecimationPercentageElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoDecimationPercentageElement *) x));
}
static void *_p_SoDecimationTypeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoDecimationTypeElement *) x));
}
static void *_p_SoDepthBufferElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoDepthBufferElement *) x));
}
static void *_p_SoDiffuseColorElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoDiffuseColorElement *) x));
}
static void *_p_SoDrawStyleElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoDrawStyleElement *) x));
}
static void *_p_SoEmissiveColorElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoEmissiveColorElement *) x));
}
static void *_p_SoEnvironmentElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoEnvironmentElement *) x));
}
static void *_p_SoFloatElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoFloatElement *) x));
}
static void *_p_SoFocalDistanceElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoFocalDistanceElement *) x));
}
static void *_p_SoFontNameElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoFontNameElement *) x));
}
static void *_p_SoFontSizeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoFontSizeElement *) x));
}
static void *_p_SoGLCacheContextElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoGLCacheContextElement *) x));
}
static void *_p_SoGLClipPlaneElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *)(SoClipPlaneElement *) ((SoGLClipPlaneElement *) x));
}
static void *_p_SoGLColorIndexElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoGLColorIndexElement *) x));
}
static void *_p_SoGLCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoCoordinateElement *) ((SoGLCoordinateElement *) x));
}
static void *_p_SoGLDepthBufferElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoDepthBufferElement *) ((SoGLDepthBufferElement *) x));
}
static void *_p_SoGLDrawStyleElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *)(SoDrawStyleElement *) ((SoGLDrawStyleElement *) x));
}
static void *_p_SoGLEnvironmentElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoEnvironmentElement *) ((SoGLEnvironmentElement *) x));
}
static void *_p_SoGLLazyElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoLazyElement *) ((SoGLLazyElement *) x));
}
static void *_p_SoGLLightIdElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoGLLightIdElement *) x));
}
static void *_p_SoGLLinePatternElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *)(SoLinePatternElement *) ((SoGLLinePatternElement *) x));
}
static void *_p_SoGLLineWidthElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *)(SoLineWidthElement *) ((SoGLLineWidthElement *) x));
}
static void *_p_SoGLModelMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *)(SoModelMatrixElement *) ((SoGLModelMatrixElement *) x));
}
static void *_p_SoGLMultiTextureCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoMultiTextureCoordinateElement *) ((SoGLMultiTextureCoordinateElement *) x));
}
static void *_p_SoGLMultiTextureEnabledElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoMultiTextureEnabledElement *) ((SoGLMultiTextureEnabledElement *) x));
}
static void *_p_SoGLMultiTextureImageElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoMultiTextureImageElement *) ((SoGLMultiTextureImageElement *) x));
}
static void *_p_SoGLMultiTextureMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *)(SoMultiTextureMatrixElement *) ((SoGLMultiTextureMatrixElement *) x));
}
static void *_p_SoGLNormalElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoNormalElement *) ((SoGLNormalElement *) x));
}
static void *_p_SoGLPointSizeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *)(SoPointSizeElement *) ((SoGLPointSizeElement *) x));
}
static void *_p_SoGLPolygonOffsetElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoPolygonOffsetElement *) ((SoGLPolygonOffsetElement *) x));
}
static void *_p_SoGLProjectionMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoProjectionMatrixElement *) ((SoGLProjectionMatrixElement *) x));
}
static void *_p_SoGLRenderPassElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoGLRenderPassElement *) x));
}
static void *_p_SoGLShapeHintsElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoShapeHintsElement *) ((SoGLShapeHintsElement *) x));
}
static void *_p_SoGLUpdateAreaElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoGLUpdateAreaElement *) x));
}
static void *_p_SoGLVBOElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoGLVBOElement *) x));
}
static void *_p_SoGLVertexAttributeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *)(SoVertexAttributeElement *) ((SoGLVertexAttributeElement *) x));
}
static void *_p_SoGLViewingMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *)(SoViewingMatrixElement *) ((SoGLViewingMatrixElement *) x));
}
static void *_p_SoGLViewportRegionElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoViewportRegionElement *) ((SoGLViewportRegionElement *) x));
}
static void *_p_SoInt32ElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoInt32Element *) x));
}
static void *_p_SoLazyElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoLazyElement *) x));
}
static void *_p_SoLightAttenuationElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoLightAttenuationElement *) x));
}
static void *_p_SoLightElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoLightElement *) x));
}
static void *_p_SoLightModelElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoLightModelElement *) x));
}
static void *_p_SoLinePatternElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoLinePatternElement *) x));
}
static void *_p_SoLineWidthElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoLineWidthElement *) x));
}
static void *_p_SoListenerDopplerElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoListenerDopplerElement *) x));
}
static void *_p_SoListenerGainElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoListenerGainElement *) x));
}
static void *_p_SoListenerOrientationElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoListenerOrientationElement *) x));
}
static void *_p_SoListenerPositionElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoListenerPositionElement *) x));
}
static void *_p_SoLocalBBoxMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoLocalBBoxMatrixElement *) x));
}
static void *_p_SoMaterialBindingElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoMaterialBindingElement *) x));
}
static void *_p_SoModelMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoModelMatrixElement *) x));
}
static void *_p_SoMultiTextureCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoMultiTextureCoordinateElement *) x));
}
static void *_p_SoMultiTextureEnabledElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoMultiTextureEnabledElement *) x));
}
static void *_p_SoMultiTextureImageElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoMultiTextureImageElement *) x));
}
static void *_p_SoMultiTextureMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoMultiTextureMatrixElement *) x));
}
static void *_p_SoNormalBindingElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoNormalBindingElement *) x));
}
static void *_p_SoNormalElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoNormalElement *) x));
}
static void *_p_SoOverrideElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoOverrideElement *) x));
}
static void *_p_SoPickRayElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoPickRayElement *) x));
}
static void *_p_SoPickStyleElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoPickStyleElement *) x));
}
static void *_p_SoPointSizeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoPointSizeElement *) x));
}
static void *_p_SoPolygonOffsetElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoPolygonOffsetElement *) x));
}
static void *_p_SoProfileCoordinateElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoProfileCoordinateElement *) x));
}
static void *_p_SoProfileElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoProfileElement *) x));
}
static void *_p_SoProjectionMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoProjectionMatrixElement *) x));
}
static void *_p_SoReplacedElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoReplacedElement *) x));
}
static void *_p_SoShapeHintsElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoShapeHintsElement *) x));
}
static void *_p_SoShapeStyleElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoShapeStyleElement *) x));
}
static void *_p_SoShininessElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoShininessElement *) x));
}
static void *_p_SoSoundElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoSoundElement *) x));
}
static void *_p_SoSpecularColorElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoSpecularColorElement *) x));
}
static void *_p_SoSwitchElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoSwitchElement *) x));
}
static void *_p_SoTextOutlineEnabledElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoTextOutlineEnabledElement *) x));
}
static void *_p_SoTextureCombineElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoTextureCombineElement *) x));
}
static void *_p_SoTextureCoordinateBindingElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoTextureCoordinateBindingElement *) x));
}
static void *_p_SoTextureOverrideElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoTextureOverrideElement *) x));
}
static void *_p_SoTextureQualityElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoFloatElement *) ((SoTextureQualityElement *) x));
}
static void *_p_SoTextureUnitElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoTextureUnitElement *) x));
}
static void *_p_SoTransparencyElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoTransparencyElement *) x));
}
static void *_p_SoUnitsElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoUnitsElement *) x));
}
static void *_p_SoVertexAttributeBindingElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoInt32Element *) ((SoVertexAttributeBindingElement *) x));
}
static void *_p_SoVertexAttributeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoAccumulatedElement *) ((SoVertexAttributeElement *) x));
}
static void *_p_SoViewVolumeElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoViewVolumeElement *) x));
}
static void *_p_SoViewingMatrixElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *) (SoReplacedElement *) ((SoViewingMatrixElement *) x));
}
static void *_p_SoViewportRegionElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoViewportRegionElement *) x));
}
static void *_p_SoWindowElementTo_p_SoElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoElement *)  ((SoWindowElement *) x));
}
static void *_p_SoBoolOperationTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoBoolOperation *) x));
}
static void *_p_SoCalculatorTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoCalculator *) x));
}
static void *_p_SoComposeMatrixTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeMatrix *) x));
}
static void *_p_SoComposeRotationTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeRotation *) x));
}
static void *_p_SoComposeRotationFromToTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeRotationFromTo *) x));
}
static void *_p_SoComposeVec2fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeVec2f *) x));
}
static void *_p_SoComposeVec3fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeVec3f *) x));
}
static void *_p_SoComposeVec4fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComposeVec4f *) x));
}
static void *_p_SoComputeBoundingBoxTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoComputeBoundingBox *) x));
}
static void *_p_SoConcatenateTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoConcatenate *) x));
}
static void *_p_SoCounterTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoCounter *) x));
}
static void *_p_SoDecomposeMatrixTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoDecomposeMatrix *) x));
}
static void *_p_SoDecomposeRotationTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoDecomposeRotation *) x));
}
static void *_p_SoDecomposeVec2fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoDecomposeVec2f *) x));
}
static void *_p_SoDecomposeVec3fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoDecomposeVec3f *) x));
}
static void *_p_SoDecomposeVec4fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoDecomposeVec4f *) x));
}
static void *_p_SoElapsedTimeTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoElapsedTime *) x));
}
static void *_p_SoFieldConverterTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoFieldConverter *) x));
}
static void *_p_SoGateTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoGate *) x));
}
static void *_p_SoHeightMapToNormalMapTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoTexture2Convert *) ((SoHeightMapToNormalMap *) x));
}
static void *_p_SoInterpolateTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoInterpolate *) x));
}
static void *_p_SoInterpolateFloatTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoInterpolate *) ((SoInterpolateFloat *) x));
}
static void *_p_SoInterpolateRotationTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoInterpolate *) ((SoInterpolateRotation *) x));
}
static void *_p_SoInterpolateVec2fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoInterpolate *) ((SoInterpolateVec2f *) x));
}
static void *_p_SoInterpolateVec3fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoInterpolate *) ((SoInterpolateVec3f *) x));
}
static void *_p_SoInterpolateVec4fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *) (SoInterpolate *) ((SoInterpolateVec4f *) x));
}
static void *_p_SoOnOffTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoOnOff *) x));
}
static void *_p_SoOneShotTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoOneShot *) x));
}
static void *_p_SoSelectOneTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoSelectOne *) x));
}
static void *_p_SoTexture2ConvertTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoTexture2Convert *) x));
}
static void *_p_SoTimeCounterTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoTimeCounter *) x));
}
static void *_p_SoTransformVec3fTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoTransformVec3f *) x));
}
static void *_p_SoTriggerAnyTo_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine *)  ((SoTriggerAny *) x));
}
static void *_p_SoGLEnvironmentElementTo_p_SoEnvironmentElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEnvironmentElement *)  ((SoGLEnvironmentElement *) x));
}
static void *_p_SoDebugErrorTo_p_SoError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoError *)  ((SoDebugError *) x));
}
static void *_p_SoMemoryErrorTo_p_SoError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoError *)  ((SoMemoryError *) x));
}
static void *_p_SoReadErrorTo_p_SoError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoError *)  ((SoReadError *) x));
}
static void *_p_SoButtonEventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *)  ((SoButtonEvent *) x));
}
static void *_p_SoKeyboardEventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *) (SoButtonEvent *) ((SoKeyboardEvent *) x));
}
static void *_p_SoLocation2EventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *)  ((SoLocation2Event *) x));
}
static void *_p_SoMotion3EventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *)  ((SoMotion3Event *) x));
}
static void *_p_SoMouseButtonEventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *) (SoButtonEvent *) ((SoMouseButtonEvent *) x));
}
static void *_p_SoSpaceballButtonEventTo_p_SoEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEvent *) (SoButtonEvent *) ((SoSpaceballButtonEvent *) x));
}
static void *_p_SoMFBitMaskTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *)(SoMFEnum *) ((SoMFBitMask *) x));
}
static void *_p_SoMFBoolTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFBool *) x));
}
static void *_p_SoMFColorTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFColor *) x));
}
static void *_p_SoMFColorRGBATo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFColorRGBA *) x));
}
static void *_p_SoMFDoubleTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFDouble *) x));
}
static void *_p_SoMFEngineTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFEngine *) x));
}
static void *_p_SoMFEnumTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFEnum *) x));
}
static void *_p_SoMFFloatTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFFloat *) x));
}
static void *_p_SoMFInt32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFInt32 *) x));
}
static void *_p_SoMFMatrixTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFMatrix *) x));
}
static void *_p_SoMFNameTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFName *) x));
}
static void *_p_SoMFNodeTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFNode *) x));
}
static void *_p_SoMFPathTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFPath *) x));
}
static void *_p_SoMFPlaneTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFPlane *) x));
}
static void *_p_SoMFRotationTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFRotation *) x));
}
static void *_p_SoMFShortTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFShort *) x));
}
static void *_p_SoMFStringTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFString *) x));
}
static void *_p_SoMFTimeTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFTime *) x));
}
static void *_p_SoMFUInt32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFUInt32 *) x));
}
static void *_p_SoMFUShortTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFUShort *) x));
}
static void *_p_SoMFVec2bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec2b *) x));
}
static void *_p_SoMFVec2dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec2d *) x));
}
static void *_p_SoMFVec2fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec2f *) x));
}
static void *_p_SoMFVec2i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec2i32 *) x));
}
static void *_p_SoMFVec2sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec2s *) x));
}
static void *_p_SoMFVec3bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec3b *) x));
}
static void *_p_SoMFVec3dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec3d *) x));
}
static void *_p_SoMFVec3fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec3f *) x));
}
static void *_p_SoMFVec3i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec3i32 *) x));
}
static void *_p_SoMFVec3sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec3s *) x));
}
static void *_p_SoMFVec4bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4b *) x));
}
static void *_p_SoMFVec4dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4d *) x));
}
static void *_p_SoMFVec4fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4f *) x));
}
static void *_p_SoMFVec4i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4i32 *) x));
}
static void *_p_SoMFVec4sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4s *) x));
}
static void *_p_SoMFVec4ubTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4ub *) x));
}
static void *_p_SoMFVec4ui32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4ui32 *) x));
}
static void *_p_SoMFVec4usTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoMField *) ((SoMFVec4us *) x));
}
static void *_p_SoMFieldTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *)  ((SoMField *) x));
}
static void *_p_SoSFBitMaskTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *)(SoSFEnum *) ((SoSFBitMask *) x));
}
static void *_p_SoSFBoolTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBool *) x));
}
static void *_p_SoSFBox2dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox2d *) x));
}
static void *_p_SoSFBox2fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox2f *) x));
}
static void *_p_SoSFBox2i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox2i32 *) x));
}
static void *_p_SoSFBox2sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox2s *) x));
}
static void *_p_SoSFBox3dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox3d *) x));
}
static void *_p_SoSFBox3fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox3f *) x));
}
static void *_p_SoSFBox3i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox3i32 *) x));
}
static void *_p_SoSFBox3sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFBox3s *) x));
}
static void *_p_SoSFColorTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFColor *) x));
}
static void *_p_SoSFColorRGBATo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFColorRGBA *) x));
}
static void *_p_SoSFDoubleTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFDouble *) x));
}
static void *_p_SoSFEngineTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFEngine *) x));
}
static void *_p_SoSFEnumTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFEnum *) x));
}
static void *_p_SoSFFloatTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFFloat *) x));
}
static void *_p_SoSFImageTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFImage *) x));
}
static void *_p_SoSFImage3To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFImage3 *) x));
}
static void *_p_SoSFInt32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFInt32 *) x));
}
static void *_p_SoSFMatrixTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFMatrix *) x));
}
static void *_p_SoSFNameTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFName *) x));
}
static void *_p_SoSFNodeTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFNode *) x));
}
static void *_p_SoSFPathTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFPath *) x));
}
static void *_p_SoSFPlaneTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFPlane *) x));
}
static void *_p_SoSFRotationTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFRotation *) x));
}
static void *_p_SoSFShortTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFShort *) x));
}
static void *_p_SoSFStringTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFString *) x));
}
static void *_p_SoSFTimeTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFTime *) x));
}
static void *_p_SoSFTriggerTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFTrigger *) x));
}
static void *_p_SoSFUInt32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFUInt32 *) x));
}
static void *_p_SoSFUShortTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFUShort *) x));
}
static void *_p_SoSFVec2bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec2b *) x));
}
static void *_p_SoSFVec2dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec2d *) x));
}
static void *_p_SoSFVec2fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec2f *) x));
}
static void *_p_SoSFVec2i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec2i32 *) x));
}
static void *_p_SoSFVec2sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec2s *) x));
}
static void *_p_SoSFVec3bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec3b *) x));
}
static void *_p_SoSFVec3dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec3d *) x));
}
static void *_p_SoSFVec3fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec3f *) x));
}
static void *_p_SoSFVec3i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec3i32 *) x));
}
static void *_p_SoSFVec3sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec3s *) x));
}
static void *_p_SoSFVec4bTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4b *) x));
}
static void *_p_SoSFVec4dTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4d *) x));
}
static void *_p_SoSFVec4fTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4f *) x));
}
static void *_p_SoSFVec4i32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4i32 *) x));
}
static void *_p_SoSFVec4sTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4s *) x));
}
static void *_p_SoSFVec4ubTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4ub *) x));
}
static void *_p_SoSFVec4ui32To_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4ui32 *) x));
}
static void *_p_SoSFVec4usTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *) (SoSField *) ((SoSFVec4us *) x));
}
static void *_p_SoSFieldTo_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField *)  ((SoSField *) x));
}
static void *_p_SoAlphaTestTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoAlphaTest *) x));
}
static void *_p_SoAnnotationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *) ((SoAnnotation *) x));
}
static void *_p_SoAntiSquishTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoAntiSquish *) x));
}
static void *_p_SoAppearanceKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoAppearanceKit *) x));
}
static void *_p_SoArrayTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoArray *) x));
}
static void *_p_SoAsciiTextTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoAsciiText *) x));
}
static void *_p_SoBaseColorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoBaseColor *) x));
}
static void *_p_SoBaseKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoBaseKit *) x));
}
static void *_p_SoBlinkerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSwitch *) ((SoBlinker *) x));
}
static void *_p_SoBoolOperationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoBoolOperation *) x));
}
static void *_p_SoBumpMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoBumpMap *) x));
}
static void *_p_SoBumpMapCoordinateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoBumpMapCoordinate *) x));
}
static void *_p_SoBumpMapTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoBumpMapTransform *) x));
}
static void *_p_SoCacheHintTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoCacheHint *) x));
}
static void *_p_SoCalculatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoCalculator *) x));
}
static void *_p_SoCallbackTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoCallback *) x));
}
static void *_p_SoCameraTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoCamera *) x));
}
static void *_p_SoCameraKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoCameraKit *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoCenterballDragger *) x));
}
static void *_p_SoCenterballManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoCenterballManip *) x));
}
static void *_p_SoClipPlaneTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoClipPlane *) x));
}
static void *_p_SoClipPlaneManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoClipPlane *) ((SoClipPlaneManip *) x));
}
static void *_p_SoColorIndexTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoColorIndex *) x));
}
static void *_p_SoComplexityTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoComplexity *) x));
}
static void *_p_SoComposeMatrixTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeMatrix *) x));
}
static void *_p_SoComposeRotationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeRotation *) x));
}
static void *_p_SoComposeRotationFromToTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeRotationFromTo *) x));
}
static void *_p_SoComposeVec2fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeVec2f *) x));
}
static void *_p_SoComposeVec3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeVec3f *) x));
}
static void *_p_SoComposeVec4fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComposeVec4f *) x));
}
static void *_p_SoComputeBoundingBoxTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoComputeBoundingBox *) x));
}
static void *_p_SoConcatenateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoConcatenate *) x));
}
static void *_p_SoConeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoCone *) x));
}
static void *_p_SoCoordinate3To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoCoordinate3 *) x));
}
static void *_p_SoCoordinate4To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoCoordinate4 *) x));
}
static void *_p_SoCounterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoCounter *) x));
}
static void *_p_SoCubeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoCube *) x));
}
static void *_p_SoCylinderTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoCylinder *) x));
}
static void *_p_SoDecomposeMatrixTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoDecomposeMatrix *) x));
}
static void *_p_SoDecomposeRotationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoDecomposeRotation *) x));
}
static void *_p_SoDecomposeVec2fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoDecomposeVec2f *) x));
}
static void *_p_SoDecomposeVec3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoDecomposeVec3f *) x));
}
static void *_p_SoDecomposeVec4fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoDecomposeVec4f *) x));
}
static void *_p_SoDepthBufferTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoDepthBuffer *) x));
}
static void *_p_SoDirectionalLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *) ((SoDirectionalLight *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDirectionalLightManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *)(SoDirectionalLight *) ((SoDirectionalLightManip *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDragPointDragger *) x));
}
static void *_p_SoDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *) ((SoDragger *) x));
}
static void *_p_SoDrawStyleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoDrawStyle *) x));
}
static void *_p_SoElapsedTimeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoElapsedTime *) x));
}
static void *_p_SoEngineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *)  ((SoEngine *) x));
}
static void *_p_SoEnvironmentTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoEnvironment *) x));
}
static void *_p_SoEventCallbackTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoEventCallback *) x));
}
static void *_p_SoExtSelectionTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *)(SoSelection *) ((SoExtSelection *) x));
}
static void *_p_SoFaceSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet *) x));
}
static void *_p_SoFieldConverterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoFieldConverter *) x));
}
static void *_p_SoFileTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoFile *) x));
}
static void *_p_SoFontTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoFont *) x));
}
static void *_p_SoFontStyleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoFont *) ((SoFontStyle *) x));
}
static void *_p_SoFragmentShaderTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderObject *) ((SoFragmentShader *) x));
}
static void *_p_SoFrustumCameraTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoCamera *) ((SoFrustumCamera *) x));
}
static void *_p_SoGateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoGate *) x));
}
static void *_p_SoGeoCoordinateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoGeoCoordinate *) x));
}
static void *_p_SoGeoLocationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoGeoLocation *) x));
}
static void *_p_SoGeoOriginTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoGeoOrigin *) x));
}
static void *_p_SoGeoSeparatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *) ((SoGeoSeparator *) x));
}
static void *_p_SoGroupTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoGroup *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoHandleBoxManip *) x));
}
static void *_p_SoHeightMapToNormalMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoTexture2Convert *) ((SoHeightMapToNormalMap *) x));
}
static void *_p_SoImageTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoImage *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedNurbsCurveTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoIndexedNurbsCurve *) x));
}
static void *_p_SoIndexedNurbsSurfaceTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoIndexedNurbsSurface *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *) ((SoIndexedShape *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoInfoTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoInfo *) x));
}
static void *_p_SoInteractionKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoInteractionKit *) x));
}
static void *_p_SoInterpolateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoInterpolate *) x));
}
static void *_p_SoInterpolateFloatTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoInterpolate *) ((SoInterpolateFloat *) x));
}
static void *_p_SoInterpolateRotationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoInterpolate *) ((SoInterpolateRotation *) x));
}
static void *_p_SoInterpolateVec2fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoInterpolate *) ((SoInterpolateVec2f *) x));
}
static void *_p_SoInterpolateVec3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoInterpolate *) ((SoInterpolateVec3f *) x));
}
static void *_p_SoInterpolateVec4fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *)(SoInterpolate *) ((SoInterpolateVec4f *) x));
}
static void *_p_SoJackDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoJackDragger *) x));
}
static void *_p_SoJackManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoJackManip *) x));
}
static void *_p_SoLODTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoLOD *) x));
}
static void *_p_SoLabelTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoLabel *) x));
}
static void *_p_SoLevelOfDetailTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoLevelOfDetail *) x));
}
static void *_p_SoLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoLight *) x));
}
static void *_p_SoLightKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoLightKit *) x));
}
static void *_p_SoLightModelTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoLightModel *) x));
}
static void *_p_SoLineSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet *) x));
}
static void *_p_SoLinearProfileTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoProfile *) ((SoLinearProfile *) x));
}
static void *_p_SoListenerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoListener *) x));
}
static void *_p_SoLocateHighlightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *) ((SoLocateHighlight *) x));
}
static void *_p_SoMarkerSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoMaterialTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoMaterial *) x));
}
static void *_p_SoMaterialBindingTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoMaterialBinding *) x));
}
static void *_p_SoMatrixTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoMatrixTransform *) x));
}
static void *_p_SoMultipleCopyTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoMultipleCopy *) x));
}
static void *_p_SoNodeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *)  ((SoNode *) x));
}
static void *_p_SoNodeEngineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoNodeEngine *) x));
}
static void *_p_SoNodeKitListPartTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoNodeKitListPart *) x));
}
static void *_p_SoNonIndexedShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *) ((SoNonIndexedShape *) x));
}
static void *_p_SoNormalTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoNormal *) x));
}
static void *_p_SoNormalBindingTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoNormalBinding *) x));
}
static void *_p_SoNurbsCurveTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoNurbsCurve *) x));
}
static void *_p_SoNurbsProfileTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoProfile *) ((SoNurbsProfile *) x));
}
static void *_p_SoNurbsSurfaceTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoNurbsSurface *) x));
}
static void *_p_SoOnOffTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoOnOff *) x));
}
static void *_p_SoOneShotTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoOneShot *) x));
}
static void *_p_SoOrthographicCameraTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoCamera *) ((SoOrthographicCamera *) x));
}
static void *_p_SoPackedColorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoPackedColor *) x));
}
static void *_p_SoPathSwitchTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoPathSwitch *) x));
}
static void *_p_SoPendulumTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoRotation *) ((SoPendulum *) x));
}
static void *_p_SoPerspectiveCameraTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoCamera *) ((SoPerspectiveCamera *) x));
}
static void *_p_SoPickStyleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoPickStyle *) x));
}
static void *_p_SoPointLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *) ((SoPointLight *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoPointLightDragger *) x));
}
static void *_p_SoPointLightManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *)(SoPointLight *) ((SoPointLightManip *) x));
}
static void *_p_SoPointSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet *) x));
}
static void *_p_SoPolygonOffsetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoPolygonOffset *) x));
}
static void *_p_SoProfileTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoProfile *) x));
}
static void *_p_SoProfileCoordinate2To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoProfileCoordinate2 *) x));
}
static void *_p_SoProfileCoordinate3To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoProfileCoordinate3 *) x));
}
static void *_p_SoProtoTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoProto *) x));
}
static void *_p_SoProtoInstanceTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoProtoInstance *) x));
}
static void *_p_SoQuadMeshTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh *) x));
}
static void *_p_SoResetTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoResetTransform *) x));
}
static void *_p_SoReversePerspectiveCameraTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoCamera *)(SoPerspectiveCamera *) ((SoReversePerspectiveCamera *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger *) x));
}
static void *_p_SoRotationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoRotation *) x));
}
static void *_p_SoRotationXYZTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoRotationXYZ *) x));
}
static void *_p_SoRotorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoRotation *) ((SoRotor *) x));
}
static void *_p_SoScaleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoScale *) x));
}
static void *_p_SoScale1DraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger *) x));
}
static void *_p_SoSceneKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoSceneKit *) x));
}
static void *_p_SoSceneTexture2To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoSceneTexture2 *) x));
}
static void *_p_SoSceneTextureCubeMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoSceneTextureCubeMap *) x));
}
static void *_p_SoSelectOneTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoSelectOne *) x));
}
static void *_p_SoSelectionTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *) ((SoSelection *) x));
}
static void *_p_SoSeparatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoSeparator *) x));
}
static void *_p_SoSeparatorKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *) ((SoSeparatorKit *) x));
}
static void *_p_SoShaderObjectTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoShaderObject *) x));
}
static void *_p_SoShaderParameterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoShaderParameter *) x));
}
static void *_p_SoShaderParameter1fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1f *) x));
}
static void *_p_SoShaderParameter1iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1i *) x));
}
static void *_p_SoShaderParameter2fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2f *) x));
}
static void *_p_SoShaderParameter2iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2i *) x));
}
static void *_p_SoShaderParameter3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3f *) x));
}
static void *_p_SoShaderParameter3iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3i *) x));
}
static void *_p_SoShaderParameter4fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4f *) x));
}
static void *_p_SoShaderParameter4iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4i *) x));
}
static void *_p_SoShaderParameterArray1fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1f *) x));
}
static void *_p_SoShaderParameterArray1iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1i *) x));
}
static void *_p_SoShaderParameterArray2fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2f *) x));
}
static void *_p_SoShaderParameterArray2iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2i *) x));
}
static void *_p_SoShaderParameterArray3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3f *) x));
}
static void *_p_SoShaderParameterArray3iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3i *) x));
}
static void *_p_SoShaderParameterArray4fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4f *) x));
}
static void *_p_SoShaderParameterArray4iTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4i *) x));
}
static void *_p_SoShaderParameterMatrixTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrix *) x));
}
static void *_p_SoShaderParameterMatrixArrayTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrixArray *) x));
}
static void *_p_SoShaderProgramTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoShaderProgram *) x));
}
static void *_p_SoShaderStateMatrixParameterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderStateMatrixParameter *) x));
}
static void *_p_SoShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoShape *) x));
}
static void *_p_SoShapeHintsTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoShapeHints *) x));
}
static void *_p_SoShapeKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoShapeKit *) x));
}
static void *_p_SoShuttleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTranslation *) ((SoShuttle *) x));
}
static void *_p_SoSphereTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoSphere *) x));
}
static void *_p_SoSpotLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *) ((SoSpotLight *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger *) x));
}
static void *_p_SoSpotLightManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoLight *)(SoSpotLight *) ((SoSpotLightManip *) x));
}
static void *_p_SoSurroundScaleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoSurroundScale *) x));
}
static void *_p_SoSwitchTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoSwitch *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger *) x));
}
static void *_p_SoTabBoxManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTabBoxManip *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger *) x));
}
static void *_p_SoText2To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoText2 *) x));
}
static void *_p_SoText3To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoText3 *) x));
}
static void *_p_SoTextureTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTexture *) x));
}
static void *_p_SoTexture2To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTexture *) ((SoTexture2 *) x));
}
static void *_p_SoTexture2ConvertTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoTexture2Convert *) x));
}
static void *_p_SoTexture2TransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTexture2Transform *) x));
}
static void *_p_SoTexture3To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTexture *) ((SoTexture3 *) x));
}
static void *_p_SoTexture3TransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTexture3Transform *) x));
}
static void *_p_SoTextureCombineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCombine *) x));
}
static void *_p_SoTextureCoordinate2To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinate2 *) x));
}
static void *_p_SoTextureCoordinate3To_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinate3 *) x));
}
static void *_p_SoTextureCoordinateBindingTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinateBinding *) x));
}
static void *_p_SoTextureCoordinateCubeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinateCube *) x));
}
static void *_p_SoTextureCoordinateCylinderTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinateCylinder *) x));
}
static void *_p_SoTextureCoordinateDefaultTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateDefault *) x));
}
static void *_p_SoTextureCoordinateEnvironmentTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateEnvironment *) x));
}
static void *_p_SoTextureCoordinateFunctionTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinateFunction *) x));
}
static void *_p_SoTextureCoordinateNormalMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateNormalMap *) x));
}
static void *_p_SoTextureCoordinateObjectTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateObject *) x));
}
static void *_p_SoTextureCoordinatePlaneTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinatePlane *) x));
}
static void *_p_SoTextureCoordinateReflectionMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateReflectionMap *) x));
}
static void *_p_SoTextureCoordinateSphereTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureCoordinateSphere *) x));
}
static void *_p_SoTextureCubeMapTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTexture *) ((SoTextureCubeMap *) x));
}
static void *_p_SoTextureMatrixTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureMatrixTransform *) x));
}
static void *_p_SoTextureScalePolicyTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureScalePolicy *) x));
}
static void *_p_SoTextureUnitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTextureUnit *) x));
}
static void *_p_SoTimeCounterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoTimeCounter *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTrackballDragger *) x));
}
static void *_p_SoTrackballManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTrackballManip *) x));
}
static void *_p_SoTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoTransform *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *) ((SoTransformManip *) x));
}
static void *_p_SoTransformSeparatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoTransformSeparator *) x));
}
static void *_p_SoTransformVec3fTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoTransformVec3f *) x));
}
static void *_p_SoTransformationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTransformation *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformerDragger *) x));
}
static void *_p_SoTransformerManipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformerManip *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger *) x));
}
static void *_p_SoTranslationTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoTranslation *) x));
}
static void *_p_SoTransparencyTypeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoTransparencyType *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet *) x));
}
static void *_p_SoTriggerAnyTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoEngine *) ((SoTriggerAny *) x));
}
static void *_p_SoUniformShaderParameterTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderParameter *) ((SoUniformShaderParameter *) x));
}
static void *_p_SoUnitsTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoTransformation *) ((SoUnits *) x));
}
static void *_p_SoVRMLAnchorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLAnchor *) x));
}
static void *_p_SoVRMLAppearanceTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLAppearance *) x));
}
static void *_p_SoVRMLAudioClipTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLAudioClip *) x));
}
static void *_p_SoVRMLBackgroundTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLBackground *) x));
}
static void *_p_SoVRMLBillboardTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLBillboard *) x));
}
static void *_p_SoVRMLBoxTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLBox *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLColorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLColor *) x));
}
static void *_p_SoVRMLColorInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLColorInterpolator *) x));
}
static void *_p_SoVRMLConeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCone *) x));
}
static void *_p_SoVRMLCoordinateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLCoordinate *) x));
}
static void *_p_SoVRMLCoordinateInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator *) x));
}
static void *_p_SoVRMLCylinderTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCylinder *) x));
}
static void *_p_SoVRMLCylinderSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLCylinderSensor *) x));
}
static void *_p_SoVRMLDirectionalLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLLight *) ((SoVRMLDirectionalLight *) x));
}
static void *_p_SoVRMLDragSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLSensor *) ((SoVRMLDragSensor *) x));
}
static void *_p_SoVRMLElevationGridTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLElevationGrid *) x));
}
static void *_p_SoVRMLExtrusionTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLExtrusion *) x));
}
static void *_p_SoVRMLFogTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLFog *) x));
}
static void *_p_SoVRMLFontStyleTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLFontStyle *) x));
}
static void *_p_SoVRMLGeometryTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoVRMLGeometry *) x));
}
static void *_p_SoVRMLGroupTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLGroup *) x));
}
static void *_p_SoVRMLImageTextureTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLTexture *) ((SoVRMLImageTexture *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape *) x));
}
static void *_p_SoVRMLInlineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLInline *) x));
}
static void *_p_SoVRMLInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *) ((SoVRMLInterpolator *) x));
}
static void *_p_SoVRMLLODTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoVRMLLOD *) x));
}
static void *_p_SoVRMLLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLLight *) x));
}
static void *_p_SoVRMLMaterialTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLMaterial *) x));
}
static void *_p_SoVRMLMovieTextureTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLTexture *) ((SoVRMLMovieTexture *) x));
}
static void *_p_SoVRMLNavigationInfoTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLNavigationInfo *) x));
}
static void *_p_SoVRMLNormalTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLNormal *) x));
}
static void *_p_SoVRMLNormalInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLNormalInterpolator *) x));
}
static void *_p_SoVRMLOrientationInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator *) x));
}
static void *_p_SoVRMLParentTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoVRMLParent *) x));
}
static void *_p_SoVRMLPixelTextureTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLTexture *) ((SoVRMLPixelTexture *) x));
}
static void *_p_SoVRMLPlaneSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLPlaneSensor *) x));
}
static void *_p_SoVRMLPointLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLLight *) ((SoVRMLPointLight *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLPositionInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLPositionInterpolator *) x));
}
static void *_p_SoVRMLProximitySensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLProximitySensor *) x));
}
static void *_p_SoVRMLScalarInterpolatorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLScalarInterpolator *) x));
}
static void *_p_SoVRMLScriptTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLScript *) x));
}
static void *_p_SoVRMLSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLSensor *) x));
}
static void *_p_SoVRMLShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLShape *) x));
}
static void *_p_SoVRMLSoundTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLSound *) x));
}
static void *_p_SoVRMLSphereTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLSphere *) x));
}
static void *_p_SoVRMLSphereSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLSphereSensor *) x));
}
static void *_p_SoVRMLSpotLightTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoVRMLLight *) ((SoVRMLSpotLight *) x));
}
static void *_p_SoVRMLSwitchTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *) ((SoVRMLSwitch *) x));
}
static void *_p_SoVRMLTextTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLText *) x));
}
static void *_p_SoVRMLTextureTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLTexture *) x));
}
static void *_p_SoVRMLTextureCoordinateTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLTextureCoordinate *) x));
}
static void *_p_SoVRMLTextureTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLTextureTransform *) x));
}
static void *_p_SoVRMLTimeSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoNodeEngine *) ((SoVRMLTimeSensor *) x));
}
static void *_p_SoVRMLTouchSensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLTouchSensor *) x));
}
static void *_p_SoVRMLTransformTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform *) x));
}
static void *_p_SoVRMLVertexLineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexLine *) x));
}
static void *_p_SoVRMLVertexPointTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexPoint *) x));
}
static void *_p_SoVRMLVertexShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexShape *) x));
}
static void *_p_SoVRMLViewpointTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLViewpoint *) x));
}
static void *_p_SoVRMLVisibilitySensorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLVisibilitySensor *) x));
}
static void *_p_SoVRMLWorldInfoTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVRMLWorldInfo *) x));
}
static void *_p_SoVertexAttributeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVertexAttribute *) x));
}
static void *_p_SoVertexAttributeBindingTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVertexAttributeBinding *) x));
}
static void *_p_SoVertexPropertyTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoVertexProperty *) x));
}
static void *_p_SoVertexShaderTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShaderObject *) ((SoVertexShader *) x));
}
static void *_p_SoVertexShapeTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoShape *) ((SoVertexShape *) x));
}
static void *_p_SoWWWAnchorTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoGroup *)(SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor *) x));
}
static void *_p_SoWWWInlineTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *) ((SoWWWInline *) x));
}
static void *_p_SoWrapperKitTo_p_SoFieldContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFieldContainer *) (SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoWrapperKit *) x));
}
static void *_p_SoComplexityElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoComplexityElement *) x));
}
static void *_p_SoCreaseAngleElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoCreaseAngleElement *) x));
}
static void *_p_SoDecimationPercentageElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoDecimationPercentageElement *) x));
}
static void *_p_SoFocalDistanceElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoFocalDistanceElement *) x));
}
static void *_p_SoFontSizeElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoFontSizeElement *) x));
}
static void *_p_SoGLLineWidthElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *) (SoLineWidthElement *) ((SoGLLineWidthElement *) x));
}
static void *_p_SoGLPointSizeElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *) (SoPointSizeElement *) ((SoGLPointSizeElement *) x));
}
static void *_p_SoLineWidthElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoLineWidthElement *) x));
}
static void *_p_SoListenerGainElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoListenerGainElement *) x));
}
static void *_p_SoPointSizeElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoPointSizeElement *) x));
}
static void *_p_SoTextureQualityElementTo_p_SoFloatElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFloatElement *)  ((SoTextureQualityElement *) x));
}
static void *_p_SoFontStyleTo_p_SoFont(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFont *)  ((SoFontStyle *) x));
}
static void *_p_SoTempPathTo_p_SoFullPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoFullPath *)  ((SoTempPath *) x));
}
static void *_p_SoGLBigImageTo_p_SoGLImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGLImage *)  ((SoGLBigImage *) x));
}
static void *_p_SoBoxHighlightRenderActionTo_p_SoGLRenderAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGLRenderAction *)  ((SoBoxHighlightRenderAction *) x));
}
static void *_p_SoLineHighlightRenderActionTo_p_SoGLRenderAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGLRenderAction *)  ((SoLineHighlightRenderAction *) x));
}
static void *_p_SoAnnotationTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *) ((SoAnnotation *) x));
}
static void *_p_SoArrayTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoArray *) x));
}
static void *_p_SoBlinkerTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSwitch *) ((SoBlinker *) x));
}
static void *_p_SoExtSelectionTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *)(SoSelection *) ((SoExtSelection *) x));
}
static void *_p_SoGeoSeparatorTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *) ((SoGeoSeparator *) x));
}
static void *_p_SoLODTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoLOD *) x));
}
static void *_p_SoLevelOfDetailTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoLevelOfDetail *) x));
}
static void *_p_SoLocateHighlightTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *) ((SoLocateHighlight *) x));
}
static void *_p_SoMultipleCopyTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoMultipleCopy *) x));
}
static void *_p_SoPathSwitchTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoPathSwitch *) x));
}
static void *_p_SoSelectionTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *) ((SoSelection *) x));
}
static void *_p_SoSeparatorTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoSeparator *) x));
}
static void *_p_SoSwitchTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoSwitch *) x));
}
static void *_p_SoTransformSeparatorTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoTransformSeparator *) x));
}
static void *_p_SoVRMLAnchorTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoVRMLParent *) ((SoVRMLAnchor *) x));
}
static void *_p_SoVRMLBillboardTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoVRMLParent *) ((SoVRMLBillboard *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLGroupTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoVRMLParent *) ((SoVRMLGroup *) x));
}
static void *_p_SoVRMLLODTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoVRMLLOD *) x));
}
static void *_p_SoVRMLParentTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoVRMLParent *) x));
}
static void *_p_SoVRMLSwitchTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *)  ((SoVRMLSwitch *) x));
}
static void *_p_SoVRMLTransformTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform *) x));
}
static void *_p_SoWWWAnchorTo_p_SoGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGroup *) (SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoIndexedPointSet(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedPointSet *)  ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedShape *)  ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedShape *)  ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedShape *) (SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedShape *)  ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoIndexedShape *)  ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoAnnoText3CharOrientElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoAnnoText3CharOrientElement *) x));
}
static void *_p_SoAnnoText3FontSizeHintElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoAnnoText3FontSizeHintElement *) x));
}
static void *_p_SoAnnoText3RenderPrintElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoAnnoText3RenderPrintElement *) x));
}
static void *_p_SoComplexityTypeElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoComplexityTypeElement *) x));
}
static void *_p_SoDecimationTypeElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoDecimationTypeElement *) x));
}
static void *_p_SoDrawStyleElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoDrawStyleElement *) x));
}
static void *_p_SoGLDrawStyleElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *) (SoDrawStyleElement *) ((SoGLDrawStyleElement *) x));
}
static void *_p_SoGLLightIdElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoGLLightIdElement *) x));
}
static void *_p_SoGLLinePatternElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *) (SoLinePatternElement *) ((SoGLLinePatternElement *) x));
}
static void *_p_SoLightModelElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoLightModelElement *) x));
}
static void *_p_SoLinePatternElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoLinePatternElement *) x));
}
static void *_p_SoMaterialBindingElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoMaterialBindingElement *) x));
}
static void *_p_SoNormalBindingElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoNormalBindingElement *) x));
}
static void *_p_SoPickStyleElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoPickStyleElement *) x));
}
static void *_p_SoSwitchElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoSwitchElement *) x));
}
static void *_p_SoTextOutlineEnabledElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoTextOutlineEnabledElement *) x));
}
static void *_p_SoTextureCoordinateBindingElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoTextureCoordinateBindingElement *) x));
}
static void *_p_SoTextureUnitElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoTextureUnitElement *) x));
}
static void *_p_SoUnitsElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoUnitsElement *) x));
}
static void *_p_SoVertexAttributeBindingElementTo_p_SoInt32Element(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInt32Element *)  ((SoVertexAttributeBindingElement *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoCenterballDragger *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoDragPointDragger *) x));
}
static void *_p_SoDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *)  ((SoDragger *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoHandleBoxDragger *) x));
}
static void *_p_SoJackDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoJackDragger *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoPointLightDragger *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoRotateSphericalDragger *) x));
}
static void *_p_SoScale1DraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoScaleUniformDragger *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoSpotLightDragger *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTabBoxDragger *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTabPlaneDragger *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTrackballDragger *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTransformerDragger *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoInteractionKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInteractionKit *) (SoDragger *) ((SoTranslate2Dragger *) x));
}
static void *_p_SoInterpolateFloatTo_p_SoInterpolate(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInterpolate *)  ((SoInterpolateFloat *) x));
}
static void *_p_SoInterpolateRotationTo_p_SoInterpolate(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInterpolate *)  ((SoInterpolateRotation *) x));
}
static void *_p_SoInterpolateVec2fTo_p_SoInterpolate(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInterpolate *)  ((SoInterpolateVec2f *) x));
}
static void *_p_SoInterpolateVec3fTo_p_SoInterpolate(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInterpolate *)  ((SoInterpolateVec3f *) x));
}
static void *_p_SoInterpolateVec4fTo_p_SoInterpolate(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoInterpolate *)  ((SoInterpolateVec4f *) x));
}
static void *_p_SoGLLazyElementTo_p_SoLazyElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLazyElement *)  ((SoGLLazyElement *) x));
}
static void *_p_SoDirectionalLightTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *)  ((SoDirectionalLight *) x));
}
static void *_p_SoDirectionalLightManipTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *) (SoDirectionalLight *) ((SoDirectionalLightManip *) x));
}
static void *_p_SoPointLightTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *)  ((SoPointLight *) x));
}
static void *_p_SoPointLightManipTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *) (SoPointLight *) ((SoPointLightManip *) x));
}
static void *_p_SoSpotLightTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *)  ((SoSpotLight *) x));
}
static void *_p_SoSpotLightManipTo_p_SoLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLight *) (SoSpotLight *) ((SoSpotLightManip *) x));
}
static void *_p_SoGLLinePatternElementTo_p_SoLinePatternElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLinePatternElement *)  ((SoGLLinePatternElement *) x));
}
static void *_p_SoGLLineWidthElementTo_p_SoLineWidthElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLineWidthElement *)  ((SoGLLineWidthElement *) x));
}
static void *_p_SoWWWAnchorTo_p_SoLocateHighlight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoLocateHighlight *)  ((SoWWWAnchor *) x));
}
static void *_p_SoMFBitMaskTo_p_SoMFEnum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMFEnum *)  ((SoMFBitMask *) x));
}
static void *_p_SoMFBitMaskTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *) (SoMFEnum *) ((SoMFBitMask *) x));
}
static void *_p_SoMFBoolTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFBool *) x));
}
static void *_p_SoMFColorTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFColor *) x));
}
static void *_p_SoMFColorRGBATo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFColorRGBA *) x));
}
static void *_p_SoMFDoubleTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFDouble *) x));
}
static void *_p_SoMFEngineTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFEngine *) x));
}
static void *_p_SoMFEnumTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFEnum *) x));
}
static void *_p_SoMFFloatTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFFloat *) x));
}
static void *_p_SoMFInt32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFInt32 *) x));
}
static void *_p_SoMFMatrixTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFMatrix *) x));
}
static void *_p_SoMFNameTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFName *) x));
}
static void *_p_SoMFNodeTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFNode *) x));
}
static void *_p_SoMFPathTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFPath *) x));
}
static void *_p_SoMFPlaneTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFPlane *) x));
}
static void *_p_SoMFRotationTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFRotation *) x));
}
static void *_p_SoMFShortTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFShort *) x));
}
static void *_p_SoMFStringTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFString *) x));
}
static void *_p_SoMFTimeTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFTime *) x));
}
static void *_p_SoMFUInt32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFUInt32 *) x));
}
static void *_p_SoMFUShortTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFUShort *) x));
}
static void *_p_SoMFVec2bTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec2b *) x));
}
static void *_p_SoMFVec2dTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec2d *) x));
}
static void *_p_SoMFVec2fTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec2f *) x));
}
static void *_p_SoMFVec2i32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec2i32 *) x));
}
static void *_p_SoMFVec2sTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec2s *) x));
}
static void *_p_SoMFVec3bTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec3b *) x));
}
static void *_p_SoMFVec3dTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec3d *) x));
}
static void *_p_SoMFVec3fTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec3f *) x));
}
static void *_p_SoMFVec3i32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec3i32 *) x));
}
static void *_p_SoMFVec3sTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec3s *) x));
}
static void *_p_SoMFVec4bTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4b *) x));
}
static void *_p_SoMFVec4dTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4d *) x));
}
static void *_p_SoMFVec4fTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4f *) x));
}
static void *_p_SoMFVec4i32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4i32 *) x));
}
static void *_p_SoMFVec4sTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4s *) x));
}
static void *_p_SoMFVec4ubTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4ub *) x));
}
static void *_p_SoMFVec4ui32To_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4ui32 *) x));
}
static void *_p_SoMFVec4usTo_p_SoMField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMField *)  ((SoMFVec4us *) x));
}
static void *_p_SoBBoxModelMatrixElementTo_p_SoModelMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoModelMatrixElement *)  ((SoBBoxModelMatrixElement *) x));
}
static void *_p_SoGLModelMatrixElementTo_p_SoModelMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoModelMatrixElement *)  ((SoGLModelMatrixElement *) x));
}
static void *_p_SoGLMultiTextureCoordinateElementTo_p_SoMultiTextureCoordinateElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMultiTextureCoordinateElement *)  ((SoGLMultiTextureCoordinateElement *) x));
}
static void *_p_SoGLMultiTextureEnabledElementTo_p_SoMultiTextureEnabledElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMultiTextureEnabledElement *)  ((SoGLMultiTextureEnabledElement *) x));
}
static void *_p_SoGLMultiTextureImageElementTo_p_SoMultiTextureImageElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMultiTextureImageElement *)  ((SoGLMultiTextureImageElement *) x));
}
static void *_p_SoGLMultiTextureMatrixElementTo_p_SoMultiTextureMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoMultiTextureMatrixElement *)  ((SoGLMultiTextureMatrixElement *) x));
}
static void *_p_SoAlphaTestTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoAlphaTest *) x));
}
static void *_p_SoAnnotationTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *) ((SoAnnotation *) x));
}
static void *_p_SoAntiSquishTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoAntiSquish *) x));
}
static void *_p_SoAppearanceKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoAppearanceKit *) x));
}
static void *_p_SoArrayTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoArray *) x));
}
static void *_p_SoAsciiTextTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoAsciiText *) x));
}
static void *_p_SoBaseColorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoBaseColor *) x));
}
static void *_p_SoBaseKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoBaseKit *) x));
}
static void *_p_SoBlinkerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSwitch *) ((SoBlinker *) x));
}
static void *_p_SoBumpMapTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoBumpMap *) x));
}
static void *_p_SoBumpMapCoordinateTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoBumpMapCoordinate *) x));
}
static void *_p_SoBumpMapTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoBumpMapTransform *) x));
}
static void *_p_SoCacheHintTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoCacheHint *) x));
}
static void *_p_SoCallbackTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoCallback *) x));
}
static void *_p_SoCameraTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoCamera *) x));
}
static void *_p_SoCameraKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoCameraKit *) x));
}
static void *_p_SoCenterballDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoCenterballDragger *) x));
}
static void *_p_SoCenterballManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoCenterballManip *) x));
}
static void *_p_SoClipPlaneTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoClipPlane *) x));
}
static void *_p_SoClipPlaneManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoClipPlane *) ((SoClipPlaneManip *) x));
}
static void *_p_SoColorIndexTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoColorIndex *) x));
}
static void *_p_SoComplexityTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoComplexity *) x));
}
static void *_p_SoConeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoCone *) x));
}
static void *_p_SoCoordinate3To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoCoordinate3 *) x));
}
static void *_p_SoCoordinate4To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoCoordinate4 *) x));
}
static void *_p_SoCubeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoCube *) x));
}
static void *_p_SoCylinderTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoCylinder *) x));
}
static void *_p_SoDepthBufferTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoDepthBuffer *) x));
}
static void *_p_SoDirectionalLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *) ((SoDirectionalLight *) x));
}
static void *_p_SoDirectionalLightDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger *) x));
}
static void *_p_SoDirectionalLightManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *)(SoDirectionalLight *) ((SoDirectionalLightManip *) x));
}
static void *_p_SoDragPointDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDragPointDragger *) x));
}
static void *_p_SoDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *) ((SoDragger *) x));
}
static void *_p_SoDrawStyleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoDrawStyle *) x));
}
static void *_p_SoEnvironmentTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoEnvironment *) x));
}
static void *_p_SoEventCallbackTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoEventCallback *) x));
}
static void *_p_SoExtSelectionTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *)(SoSelection *) ((SoExtSelection *) x));
}
static void *_p_SoFaceSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet *) x));
}
static void *_p_SoFileTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoFile *) x));
}
static void *_p_SoFontTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoFont *) x));
}
static void *_p_SoFontStyleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoFont *) ((SoFontStyle *) x));
}
static void *_p_SoFragmentShaderTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderObject *) ((SoFragmentShader *) x));
}
static void *_p_SoFrustumCameraTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoCamera *) ((SoFrustumCamera *) x));
}
static void *_p_SoGeoCoordinateTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoGeoCoordinate *) x));
}
static void *_p_SoGeoLocationTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoGeoLocation *) x));
}
static void *_p_SoGeoOriginTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoGeoOrigin *) x));
}
static void *_p_SoGeoSeparatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *) ((SoGeoSeparator *) x));
}
static void *_p_SoGroupTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoGroup *) x));
}
static void *_p_SoHandleBoxDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoHandleBoxManip *) x));
}
static void *_p_SoImageTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoImage *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedNurbsCurveTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoIndexedNurbsCurve *) x));
}
static void *_p_SoIndexedNurbsSurfaceTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoIndexedNurbsSurface *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *) ((SoIndexedShape *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoInfoTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoInfo *) x));
}
static void *_p_SoInteractionKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoInteractionKit *) x));
}
static void *_p_SoJackDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoJackDragger *) x));
}
static void *_p_SoJackManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoJackManip *) x));
}
static void *_p_SoLODTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoLOD *) x));
}
static void *_p_SoLabelTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoLabel *) x));
}
static void *_p_SoLevelOfDetailTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoLevelOfDetail *) x));
}
static void *_p_SoLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoLight *) x));
}
static void *_p_SoLightKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoLightKit *) x));
}
static void *_p_SoLightModelTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoLightModel *) x));
}
static void *_p_SoLineSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet *) x));
}
static void *_p_SoLinearProfileTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoProfile *) ((SoLinearProfile *) x));
}
static void *_p_SoListenerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoListener *) x));
}
static void *_p_SoLocateHighlightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *) ((SoLocateHighlight *) x));
}
static void *_p_SoMarkerSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoMaterialTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoMaterial *) x));
}
static void *_p_SoMaterialBindingTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoMaterialBinding *) x));
}
static void *_p_SoMatrixTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoMatrixTransform *) x));
}
static void *_p_SoMultipleCopyTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoMultipleCopy *) x));
}
static void *_p_SoNodeEngineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoNodeEngine *) x));
}
static void *_p_SoNodeKitListPartTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoNodeKitListPart *) x));
}
static void *_p_SoNonIndexedShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *) ((SoNonIndexedShape *) x));
}
static void *_p_SoNormalTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoNormal *) x));
}
static void *_p_SoNormalBindingTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoNormalBinding *) x));
}
static void *_p_SoNurbsCurveTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoNurbsCurve *) x));
}
static void *_p_SoNurbsProfileTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoProfile *) ((SoNurbsProfile *) x));
}
static void *_p_SoNurbsSurfaceTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoNurbsSurface *) x));
}
static void *_p_SoOrthographicCameraTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoCamera *) ((SoOrthographicCamera *) x));
}
static void *_p_SoPackedColorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoPackedColor *) x));
}
static void *_p_SoPathSwitchTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoPathSwitch *) x));
}
static void *_p_SoPendulumTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoRotation *) ((SoPendulum *) x));
}
static void *_p_SoPerspectiveCameraTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoCamera *) ((SoPerspectiveCamera *) x));
}
static void *_p_SoPickStyleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoPickStyle *) x));
}
static void *_p_SoPointLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *) ((SoPointLight *) x));
}
static void *_p_SoPointLightDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoPointLightDragger *) x));
}
static void *_p_SoPointLightManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *)(SoPointLight *) ((SoPointLightManip *) x));
}
static void *_p_SoPointSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet *) x));
}
static void *_p_SoPolygonOffsetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoPolygonOffset *) x));
}
static void *_p_SoProfileTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoProfile *) x));
}
static void *_p_SoProfileCoordinate2To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoProfileCoordinate2 *) x));
}
static void *_p_SoProfileCoordinate3To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoProfileCoordinate3 *) x));
}
static void *_p_SoProtoTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoProto *) x));
}
static void *_p_SoProtoInstanceTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoProtoInstance *) x));
}
static void *_p_SoQuadMeshTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh *) x));
}
static void *_p_SoResetTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoResetTransform *) x));
}
static void *_p_SoReversePerspectiveCameraTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoCamera *)(SoPerspectiveCamera *) ((SoReversePerspectiveCamera *) x));
}
static void *_p_SoRotateCylindricalDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger *) x));
}
static void *_p_SoRotateDiscDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger *) x));
}
static void *_p_SoRotateSphericalDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger *) x));
}
static void *_p_SoRotationTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoRotation *) x));
}
static void *_p_SoRotationXYZTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoRotationXYZ *) x));
}
static void *_p_SoRotorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoRotation *) ((SoRotor *) x));
}
static void *_p_SoScaleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoScale *) x));
}
static void *_p_SoScale1DraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale1Dragger *) x));
}
static void *_p_SoScale2DraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2Dragger *) x));
}
static void *_p_SoScale2UniformDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger *) x));
}
static void *_p_SoScaleUniformDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger *) x));
}
static void *_p_SoSceneKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoSceneKit *) x));
}
static void *_p_SoSceneTexture2To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoSceneTexture2 *) x));
}
static void *_p_SoSceneTextureCubeMapTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoSceneTextureCubeMap *) x));
}
static void *_p_SoSelectionTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *) ((SoSelection *) x));
}
static void *_p_SoSeparatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoSeparator *) x));
}
static void *_p_SoSeparatorKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *) ((SoSeparatorKit *) x));
}
static void *_p_SoShaderObjectTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoShaderObject *) x));
}
static void *_p_SoShaderParameterTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoShaderParameter *) x));
}
static void *_p_SoShaderParameter1fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1f *) x));
}
static void *_p_SoShaderParameter1iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1i *) x));
}
static void *_p_SoShaderParameter2fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2f *) x));
}
static void *_p_SoShaderParameter2iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2i *) x));
}
static void *_p_SoShaderParameter3fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3f *) x));
}
static void *_p_SoShaderParameter3iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3i *) x));
}
static void *_p_SoShaderParameter4fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4f *) x));
}
static void *_p_SoShaderParameter4iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4i *) x));
}
static void *_p_SoShaderParameterArray1fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1f *) x));
}
static void *_p_SoShaderParameterArray1iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1i *) x));
}
static void *_p_SoShaderParameterArray2fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2f *) x));
}
static void *_p_SoShaderParameterArray2iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2i *) x));
}
static void *_p_SoShaderParameterArray3fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3f *) x));
}
static void *_p_SoShaderParameterArray3iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3i *) x));
}
static void *_p_SoShaderParameterArray4fTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4f *) x));
}
static void *_p_SoShaderParameterArray4iTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4i *) x));
}
static void *_p_SoShaderParameterMatrixTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrix *) x));
}
static void *_p_SoShaderParameterMatrixArrayTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrixArray *) x));
}
static void *_p_SoShaderProgramTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoShaderProgram *) x));
}
static void *_p_SoShaderStateMatrixParameterTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderStateMatrixParameter *) x));
}
static void *_p_SoShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoShape *) x));
}
static void *_p_SoShapeHintsTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoShapeHints *) x));
}
static void *_p_SoShapeKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoSeparatorKit *) ((SoShapeKit *) x));
}
static void *_p_SoShuttleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTranslation *) ((SoShuttle *) x));
}
static void *_p_SoSphereTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoSphere *) x));
}
static void *_p_SoSpotLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *) ((SoSpotLight *) x));
}
static void *_p_SoSpotLightDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger *) x));
}
static void *_p_SoSpotLightManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoLight *)(SoSpotLight *) ((SoSpotLightManip *) x));
}
static void *_p_SoSurroundScaleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoSurroundScale *) x));
}
static void *_p_SoSwitchTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoSwitch *) x));
}
static void *_p_SoTabBoxDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger *) x));
}
static void *_p_SoTabBoxManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTabBoxManip *) x));
}
static void *_p_SoTabPlaneDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger *) x));
}
static void *_p_SoText2To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoText2 *) x));
}
static void *_p_SoText3To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoText3 *) x));
}
static void *_p_SoTextureTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTexture *) x));
}
static void *_p_SoTexture2To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTexture *) ((SoTexture2 *) x));
}
static void *_p_SoTexture2TransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTexture2Transform *) x));
}
static void *_p_SoTexture3To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTexture *) ((SoTexture3 *) x));
}
static void *_p_SoTexture3TransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTexture3Transform *) x));
}
static void *_p_SoTextureCombineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCombine *) x));
}
static void *_p_SoTextureCoordinate2To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinate2 *) x));
}
static void *_p_SoTextureCoordinate3To_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinate3 *) x));
}
static void *_p_SoTextureCoordinateBindingTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinateBinding *) x));
}
static void *_p_SoTextureCoordinateCubeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinateCube *) x));
}
static void *_p_SoTextureCoordinateCylinderTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinateCylinder *) x));
}
static void *_p_SoTextureCoordinateDefaultTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinateDefault *) x));
}
static void *_p_SoTextureCoordinateEnvironmentTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinateEnvironment *) x));
}
static void *_p_SoTextureCoordinateFunctionTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinateFunction *) x));
}
static void *_p_SoTextureCoordinateNormalMapTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinateNormalMap *) x));
}
static void *_p_SoTextureCoordinateObjectTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinateObject *) x));
}
static void *_p_SoTextureCoordinatePlaneTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinatePlane *) x));
}
static void *_p_SoTextureCoordinateReflectionMapTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTextureCoordinateFunction *) ((SoTextureCoordinateReflectionMap *) x));
}
static void *_p_SoTextureCoordinateSphereTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureCoordinateSphere *) x));
}
static void *_p_SoTextureCubeMapTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTexture *) ((SoTextureCubeMap *) x));
}
static void *_p_SoTextureMatrixTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureMatrixTransform *) x));
}
static void *_p_SoTextureScalePolicyTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureScalePolicy *) x));
}
static void *_p_SoTextureUnitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTextureUnit *) x));
}
static void *_p_SoTrackballDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTrackballDragger *) x));
}
static void *_p_SoTrackballManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTrackballManip *) x));
}
static void *_p_SoTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoTransform *) x));
}
static void *_p_SoTransformBoxDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *) ((SoTransformManip *) x));
}
static void *_p_SoTransformSeparatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoTransformSeparator *) x));
}
static void *_p_SoTransformationTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTransformation *) x));
}
static void *_p_SoTransformerDraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformerDragger *) x));
}
static void *_p_SoTransformerManipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformerManip *) x));
}
static void *_p_SoTranslate1DraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger *) x));
}
static void *_p_SoTranslate2DraggerTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger *) x));
}
static void *_p_SoTranslationTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoTranslation *) x));
}
static void *_p_SoTransparencyTypeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoTransparencyType *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet *) x));
}
static void *_p_SoUniformShaderParameterTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderParameter *) ((SoUniformShaderParameter *) x));
}
static void *_p_SoUnitsTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoTransformation *) ((SoUnits *) x));
}
static void *_p_SoVRMLAnchorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoVRMLParent *) ((SoVRMLAnchor *) x));
}
static void *_p_SoVRMLAppearanceTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLAppearance *) x));
}
static void *_p_SoVRMLAudioClipTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLAudioClip *) x));
}
static void *_p_SoVRMLBackgroundTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLBackground *) x));
}
static void *_p_SoVRMLBillboardTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoVRMLParent *) ((SoVRMLBillboard *) x));
}
static void *_p_SoVRMLBoxTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLBox *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLColorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLColor *) x));
}
static void *_p_SoVRMLColorInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLColorInterpolator *) x));
}
static void *_p_SoVRMLConeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLCone *) x));
}
static void *_p_SoVRMLCoordinateTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLCoordinate *) x));
}
static void *_p_SoVRMLCoordinateInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator *) x));
}
static void *_p_SoVRMLCylinderTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLCylinder *) x));
}
static void *_p_SoVRMLCylinderSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLCylinderSensor *) x));
}
static void *_p_SoVRMLDirectionalLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLLight *) ((SoVRMLDirectionalLight *) x));
}
static void *_p_SoVRMLDragSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLSensor *) ((SoVRMLDragSensor *) x));
}
static void *_p_SoVRMLElevationGridTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLElevationGrid *) x));
}
static void *_p_SoVRMLExtrusionTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLExtrusion *) x));
}
static void *_p_SoVRMLFogTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLFog *) x));
}
static void *_p_SoVRMLFontStyleTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLFontStyle *) x));
}
static void *_p_SoVRMLGeometryTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoVRMLGeometry *) x));
}
static void *_p_SoVRMLGroupTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoVRMLParent *) ((SoVRMLGroup *) x));
}
static void *_p_SoVRMLImageTextureTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLTexture *) ((SoVRMLImageTexture *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape *) x));
}
static void *_p_SoVRMLInlineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLInline *) x));
}
static void *_p_SoVRMLInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *) ((SoVRMLInterpolator *) x));
}
static void *_p_SoVRMLLODTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoVRMLLOD *) x));
}
static void *_p_SoVRMLLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLLight *) x));
}
static void *_p_SoVRMLMaterialTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLMaterial *) x));
}
static void *_p_SoVRMLMovieTextureTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLTexture *) ((SoVRMLMovieTexture *) x));
}
static void *_p_SoVRMLNavigationInfoTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLNavigationInfo *) x));
}
static void *_p_SoVRMLNormalTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLNormal *) x));
}
static void *_p_SoVRMLNormalInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLNormalInterpolator *) x));
}
static void *_p_SoVRMLOrientationInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator *) x));
}
static void *_p_SoVRMLParentTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoVRMLParent *) x));
}
static void *_p_SoVRMLPixelTextureTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLTexture *) ((SoVRMLPixelTexture *) x));
}
static void *_p_SoVRMLPlaneSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLPlaneSensor *) x));
}
static void *_p_SoVRMLPointLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLLight *) ((SoVRMLPointLight *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLPositionInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLPositionInterpolator *) x));
}
static void *_p_SoVRMLProximitySensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLProximitySensor *) x));
}
static void *_p_SoVRMLScalarInterpolatorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLScalarInterpolator *) x));
}
static void *_p_SoVRMLScriptTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLScript *) x));
}
static void *_p_SoVRMLSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLSensor *) x));
}
static void *_p_SoVRMLShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLShape *) x));
}
static void *_p_SoVRMLSoundTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLSound *) x));
}
static void *_p_SoVRMLSphereTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLSphere *) x));
}
static void *_p_SoVRMLSphereSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLSphereSensor *) x));
}
static void *_p_SoVRMLSpotLightTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoVRMLLight *) ((SoVRMLSpotLight *) x));
}
static void *_p_SoVRMLSwitchTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *) ((SoVRMLSwitch *) x));
}
static void *_p_SoVRMLTextTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLText *) x));
}
static void *_p_SoVRMLTextureTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLTexture *) x));
}
static void *_p_SoVRMLTextureCoordinateTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLTextureCoordinate *) x));
}
static void *_p_SoVRMLTextureTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLTextureTransform *) x));
}
static void *_p_SoVRMLTimeSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoNodeEngine *) ((SoVRMLTimeSensor *) x));
}
static void *_p_SoVRMLTouchSensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLTouchSensor *) x));
}
static void *_p_SoVRMLTransformTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform *) x));
}
static void *_p_SoVRMLVertexLineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexLine *) x));
}
static void *_p_SoVRMLVertexPointTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexPoint *) x));
}
static void *_p_SoVRMLVertexShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexShape *) x));
}
static void *_p_SoVRMLViewpointTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLViewpoint *) x));
}
static void *_p_SoVRMLVisibilitySensorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLVisibilitySensor *) x));
}
static void *_p_SoVRMLWorldInfoTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVRMLWorldInfo *) x));
}
static void *_p_SoVertexAttributeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVertexAttribute *) x));
}
static void *_p_SoVertexAttributeBindingTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVertexAttributeBinding *) x));
}
static void *_p_SoVertexPropertyTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoVertexProperty *) x));
}
static void *_p_SoVertexShaderTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShaderObject *) ((SoVertexShader *) x));
}
static void *_p_SoVertexShapeTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoShape *) ((SoVertexShape *) x));
}
static void *_p_SoWWWAnchorTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoGroup *)(SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor *) x));
}
static void *_p_SoWWWInlineTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *)  ((SoWWWInline *) x));
}
static void *_p_SoWrapperKitTo_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode *) (SoBaseKit *)(SoSeparatorKit *) ((SoWrapperKit *) x));
}
static void *_p_SoVRMLColorInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLColorInterpolator *) x));
}
static void *_p_SoVRMLCoordinateInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator *) x));
}
static void *_p_SoVRMLInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *)  ((SoVRMLInterpolator *) x));
}
static void *_p_SoVRMLNormalInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLNormalInterpolator *) x));
}
static void *_p_SoVRMLOrientationInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator *) x));
}
static void *_p_SoVRMLPositionInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLPositionInterpolator *) x));
}
static void *_p_SoVRMLScalarInterpolatorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *) (SoVRMLInterpolator *) ((SoVRMLScalarInterpolator *) x));
}
static void *_p_SoVRMLTimeSensorTo_p_SoNodeEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeEngine *)  ((SoVRMLTimeSensor *) x));
}
static void *_p_SoChildListTo_p_SoNodeList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNodeList *)  ((SoChildList *) x));
}
static void *_p_SoFaceSetTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *)  ((SoFaceSet *) x));
}
static void *_p_SoLineSetTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *)  ((SoLineSet *) x));
}
static void *_p_SoMarkerSetTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *) (SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoPointSetTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *)  ((SoPointSet *) x));
}
static void *_p_SoQuadMeshTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *)  ((SoQuadMesh *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoNonIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNonIndexedShape *)  ((SoTriangleStripSet *) x));
}
static void *_p_SoGLNormalElementTo_p_SoNormalElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNormalElement *)  ((SoGLNormalElement *) x));
}
static void *_p_SoFullPathTo_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *)  ((SoFullPath *) x));
}
static void *_p_SoNodeKitPathTo_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *)  ((SoNodeKitPath *) x));
}
static void *_p_SoTempPathTo_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *) (SoFullPath *) ((SoTempPath *) x));
}
static void *_p_SoReversePerspectiveCameraTo_p_SoPerspectiveCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPerspectiveCamera *)  ((SoReversePerspectiveCamera *) x));
}
static void *_p_SoRayPickActionTo_p_SoPickAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPickAction *)  ((SoRayPickAction *) x));
}
static void *_p_SoPointLightManipTo_p_SoPointLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPointLight *)  ((SoPointLightManip *) x));
}
static void *_p_SoMarkerSetTo_p_SoPointSet(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPointSet *)  ((SoMarkerSet *) x));
}
static void *_p_SoGLPointSizeElementTo_p_SoPointSizeElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPointSizeElement *)  ((SoGLPointSizeElement *) x));
}
static void *_p_SoGLPolygonOffsetElementTo_p_SoPolygonOffsetElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPolygonOffsetElement *)  ((SoGLPolygonOffsetElement *) x));
}
static void *_p_SoLinearProfileTo_p_SoProfile(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoProfile *)  ((SoLinearProfile *) x));
}
static void *_p_SoNurbsProfileTo_p_SoProfile(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoProfile *)  ((SoNurbsProfile *) x));
}
static void *_p_SoGLProjectionMatrixElementTo_p_SoProjectionMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoProjectionMatrixElement *)  ((SoGLProjectionMatrixElement *) x));
}
static void *_p_SoAmbientColorElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoAmbientColorElement *) x));
}
static void *_p_SoBumpMapCoordinateElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoBumpMapCoordinateElement *) x));
}
static void *_p_SoBumpMapElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoBumpMapElement *) x));
}
static void *_p_SoCoordinateElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoCoordinateElement *) x));
}
static void *_p_SoDiffuseColorElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoDiffuseColorElement *) x));
}
static void *_p_SoEmissiveColorElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoEmissiveColorElement *) x));
}
static void *_p_SoEnvironmentElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoEnvironmentElement *) x));
}
static void *_p_SoFontNameElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoFontNameElement *) x));
}
static void *_p_SoGLColorIndexElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoGLColorIndexElement *) x));
}
static void *_p_SoGLCoordinateElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoCoordinateElement *) ((SoGLCoordinateElement *) x));
}
static void *_p_SoGLEnvironmentElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoEnvironmentElement *) ((SoGLEnvironmentElement *) x));
}
static void *_p_SoGLNormalElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoNormalElement *) ((SoGLNormalElement *) x));
}
static void *_p_SoGLPolygonOffsetElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoPolygonOffsetElement *) ((SoGLPolygonOffsetElement *) x));
}
static void *_p_SoGLProjectionMatrixElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoProjectionMatrixElement *) ((SoGLProjectionMatrixElement *) x));
}
static void *_p_SoGLViewingMatrixElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *) (SoViewingMatrixElement *) ((SoGLViewingMatrixElement *) x));
}
static void *_p_SoLightAttenuationElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoLightAttenuationElement *) x));
}
static void *_p_SoListenerDopplerElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoListenerDopplerElement *) x));
}
static void *_p_SoListenerOrientationElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoListenerOrientationElement *) x));
}
static void *_p_SoListenerPositionElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoListenerPositionElement *) x));
}
static void *_p_SoNormalElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoNormalElement *) x));
}
static void *_p_SoPolygonOffsetElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoPolygonOffsetElement *) x));
}
static void *_p_SoProfileCoordinateElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoProfileCoordinateElement *) x));
}
static void *_p_SoProjectionMatrixElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoProjectionMatrixElement *) x));
}
static void *_p_SoShininessElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoShininessElement *) x));
}
static void *_p_SoSoundElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoSoundElement *) x));
}
static void *_p_SoSpecularColorElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoSpecularColorElement *) x));
}
static void *_p_SoTransparencyElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoTransparencyElement *) x));
}
static void *_p_SoViewVolumeElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoViewVolumeElement *) x));
}
static void *_p_SoViewingMatrixElementTo_p_SoReplacedElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoReplacedElement *)  ((SoViewingMatrixElement *) x));
}
static void *_p_SoPendulumTo_p_SoRotation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoRotation *)  ((SoPendulum *) x));
}
static void *_p_SoRotorTo_p_SoRotation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoRotation *)  ((SoRotor *) x));
}
static void *_p_SoSFBitMaskTo_p_SoSFEnum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSFEnum *)  ((SoSFBitMask *) x));
}
static void *_p_SoSFBitMaskTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *) (SoSFEnum *) ((SoSFBitMask *) x));
}
static void *_p_SoSFBoolTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBool *) x));
}
static void *_p_SoSFBox2dTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox2d *) x));
}
static void *_p_SoSFBox2fTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox2f *) x));
}
static void *_p_SoSFBox2i32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox2i32 *) x));
}
static void *_p_SoSFBox2sTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox2s *) x));
}
static void *_p_SoSFBox3dTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox3d *) x));
}
static void *_p_SoSFBox3fTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox3f *) x));
}
static void *_p_SoSFBox3i32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox3i32 *) x));
}
static void *_p_SoSFBox3sTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFBox3s *) x));
}
static void *_p_SoSFColorTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFColor *) x));
}
static void *_p_SoSFColorRGBATo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFColorRGBA *) x));
}
static void *_p_SoSFDoubleTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFDouble *) x));
}
static void *_p_SoSFEngineTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFEngine *) x));
}
static void *_p_SoSFEnumTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFEnum *) x));
}
static void *_p_SoSFFloatTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFFloat *) x));
}
static void *_p_SoSFImageTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFImage *) x));
}
static void *_p_SoSFImage3To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFImage3 *) x));
}
static void *_p_SoSFInt32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFInt32 *) x));
}
static void *_p_SoSFMatrixTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFMatrix *) x));
}
static void *_p_SoSFNameTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFName *) x));
}
static void *_p_SoSFNodeTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFNode *) x));
}
static void *_p_SoSFPathTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFPath *) x));
}
static void *_p_SoSFPlaneTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFPlane *) x));
}
static void *_p_SoSFRotationTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFRotation *) x));
}
static void *_p_SoSFShortTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFShort *) x));
}
static void *_p_SoSFStringTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFString *) x));
}
static void *_p_SoSFTimeTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFTime *) x));
}
static void *_p_SoSFTriggerTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFTrigger *) x));
}
static void *_p_SoSFUInt32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFUInt32 *) x));
}
static void *_p_SoSFUShortTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFUShort *) x));
}
static void *_p_SoSFVec2bTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec2b *) x));
}
static void *_p_SoSFVec2dTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec2d *) x));
}
static void *_p_SoSFVec2fTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec2f *) x));
}
static void *_p_SoSFVec2i32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec2i32 *) x));
}
static void *_p_SoSFVec2sTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec2s *) x));
}
static void *_p_SoSFVec3bTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec3b *) x));
}
static void *_p_SoSFVec3dTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec3d *) x));
}
static void *_p_SoSFVec3fTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec3f *) x));
}
static void *_p_SoSFVec3i32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec3i32 *) x));
}
static void *_p_SoSFVec3sTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec3s *) x));
}
static void *_p_SoSFVec4bTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4b *) x));
}
static void *_p_SoSFVec4dTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4d *) x));
}
static void *_p_SoSFVec4fTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4f *) x));
}
static void *_p_SoSFVec4i32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4i32 *) x));
}
static void *_p_SoSFVec4sTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4s *) x));
}
static void *_p_SoSFVec4ubTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4ub *) x));
}
static void *_p_SoSFVec4ui32To_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4ui32 *) x));
}
static void *_p_SoSFVec4usTo_p_SoSField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSField *)  ((SoSFVec4us *) x));
}
static void *_p_SoScXMLDollyTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLDollyTarget *) x));
}
static void *_p_SoScXMLFlightControlTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLFlightControlTarget *) x));
}
static void *_p_SoScXMLMiscTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLMiscTarget *) x));
}
static void *_p_SoScXMLMotionTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLMotionTarget *) x));
}
static void *_p_SoScXMLPanTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLPanTarget *) x));
}
static void *_p_SoScXMLRotateTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLRotateTarget *) x));
}
static void *_p_SoScXMLSeekTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLSeekTarget *) x));
}
static void *_p_SoScXMLSpinTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLSpinTarget *) x));
}
static void *_p_SoScXMLZoomTargetTo_p_SoScXMLNavigationTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoScXMLNavigationTarget *)  ((SoScXMLZoomTarget *) x));
}
static void *_p_SoExtSelectionTo_p_SoSelection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSelection *)  ((SoExtSelection *) x));
}
static void *_p_SoAlarmSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoTimerQueueSensor *) ((SoAlarmSensor *) x));
}
static void *_p_SoDataSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *) ((SoDataSensor *) x));
}
static void *_p_SoDelayQueueSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *)  ((SoDelayQueueSensor *) x));
}
static void *_p_SoFieldSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *)(SoDataSensor *) ((SoFieldSensor *) x));
}
static void *_p_SoIdleSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *) ((SoIdleSensor *) x));
}
static void *_p_SoNodeSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *)(SoDataSensor *) ((SoNodeSensor *) x));
}
static void *_p_SoOneShotSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *) ((SoOneShotSensor *) x));
}
static void *_p_SoPathSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoDelayQueueSensor *)(SoDataSensor *) ((SoPathSensor *) x));
}
static void *_p_SoTimerQueueSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *)  ((SoTimerQueueSensor *) x));
}
static void *_p_SoTimerSensorTo_p_SoSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSensor *) (SoTimerQueueSensor *) ((SoTimerSensor *) x));
}
static void *_p_SoAnnotationTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *)  ((SoAnnotation *) x));
}
static void *_p_SoExtSelectionTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *) (SoSelection *) ((SoExtSelection *) x));
}
static void *_p_SoGeoSeparatorTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *)  ((SoGeoSeparator *) x));
}
static void *_p_SoLocateHighlightTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *)  ((SoLocateHighlight *) x));
}
static void *_p_SoSelectionTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *)  ((SoSelection *) x));
}
static void *_p_SoWWWAnchorTo_p_SoSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparator *) (SoLocateHighlight *) ((SoWWWAnchor *) x));
}
static void *_p_SoShapeKitTo_p_SoSeparatorKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparatorKit *)  ((SoShapeKit *) x));
}
static void *_p_SoWrapperKitTo_p_SoSeparatorKit(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSeparatorKit *)  ((SoWrapperKit *) x));
}
static void *_p_SoFragmentShaderTo_p_SoShaderObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderObject *)  ((SoFragmentShader *) x));
}
static void *_p_SoVertexShaderTo_p_SoShaderObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderObject *)  ((SoVertexShader *) x));
}
static void *_p_SoShaderParameter1fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter1f *) x));
}
static void *_p_SoShaderParameter1iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter1i *) x));
}
static void *_p_SoShaderParameter2fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter2f *) x));
}
static void *_p_SoShaderParameter2iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter2i *) x));
}
static void *_p_SoShaderParameter3fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter3f *) x));
}
static void *_p_SoShaderParameter3iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter3i *) x));
}
static void *_p_SoShaderParameter4fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter4f *) x));
}
static void *_p_SoShaderParameter4iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameter4i *) x));
}
static void *_p_SoShaderParameterArray1fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray1f *) x));
}
static void *_p_SoShaderParameterArray1iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray1i *) x));
}
static void *_p_SoShaderParameterArray2fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray2f *) x));
}
static void *_p_SoShaderParameterArray2iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray2i *) x));
}
static void *_p_SoShaderParameterArray3fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray3f *) x));
}
static void *_p_SoShaderParameterArray3iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray3i *) x));
}
static void *_p_SoShaderParameterArray4fTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray4f *) x));
}
static void *_p_SoShaderParameterArray4iTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterArray4i *) x));
}
static void *_p_SoShaderParameterMatrixTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterMatrix *) x));
}
static void *_p_SoShaderParameterMatrixArrayTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderParameterMatrixArray *) x));
}
static void *_p_SoShaderStateMatrixParameterTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *) (SoUniformShaderParameter *) ((SoShaderStateMatrixParameter *) x));
}
static void *_p_SoUniformShaderParameterTo_p_SoShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShaderParameter *)  ((SoUniformShaderParameter *) x));
}
static void *_p_SoAsciiTextTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoAsciiText *) x));
}
static void *_p_SoConeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoCone *) x));
}
static void *_p_SoCubeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoCube *) x));
}
static void *_p_SoCylinderTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoCylinder *) x));
}
static void *_p_SoFaceSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet *) x));
}
static void *_p_SoImageTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoImage *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedNurbsCurveTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoIndexedNurbsCurve *) x));
}
static void *_p_SoIndexedNurbsSurfaceTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoIndexedNurbsSurface *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedShapeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *) ((SoIndexedShape *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoLineSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet *) x));
}
static void *_p_SoMarkerSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoNonIndexedShapeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *) ((SoNonIndexedShape *) x));
}
static void *_p_SoNurbsCurveTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoNurbsCurve *) x));
}
static void *_p_SoNurbsSurfaceTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoNurbsSurface *) x));
}
static void *_p_SoPointSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet *) x));
}
static void *_p_SoQuadMeshTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh *) x));
}
static void *_p_SoSphereTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoSphere *) x));
}
static void *_p_SoText2To_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoText2 *) x));
}
static void *_p_SoText3To_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoText3 *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet *) x));
}
static void *_p_SoVRMLBoxTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLBox *) x));
}
static void *_p_SoVRMLConeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLCone *) x));
}
static void *_p_SoVRMLCylinderTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLCylinder *) x));
}
static void *_p_SoVRMLElevationGridTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLElevationGrid *) x));
}
static void *_p_SoVRMLExtrusionTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLExtrusion *) x));
}
static void *_p_SoVRMLGeometryTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoVRMLGeometry *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLSphereTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLSphere *) x));
}
static void *_p_SoVRMLTextTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLText *) x));
}
static void *_p_SoVRMLVertexLineTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLVertexLine *) x));
}
static void *_p_SoVRMLVertexPointTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLVertexPoint *) x));
}
static void *_p_SoVRMLVertexShapeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *) (SoVRMLGeometry *) ((SoVRMLVertexShape *) x));
}
static void *_p_SoVertexShapeTo_p_SoShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShape *)  ((SoVertexShape *) x));
}
static void *_p_SoGLShapeHintsElementTo_p_SoShapeHintsElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoShapeHintsElement *)  ((SoGLShapeHintsElement *) x));
}
static void *_p_SoReorganizeActionTo_p_SoSimplifyAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSimplifyAction *)  ((SoReorganizeAction *) x));
}
static void *_p_SoSpotLightManipTo_p_SoSpotLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSpotLight *)  ((SoSpotLightManip *) x));
}
static void *_p_SoBlinkerTo_p_SoSwitch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSwitch *)  ((SoBlinker *) x));
}
static void *_p_SoTexture2To_p_SoTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTexture *)  ((SoTexture2 *) x));
}
static void *_p_SoTexture3To_p_SoTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTexture *)  ((SoTexture3 *) x));
}
static void *_p_SoTextureCubeMapTo_p_SoTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTexture *)  ((SoTextureCubeMap *) x));
}
static void *_p_SoHeightMapToNormalMapTo_p_SoTexture2Convert(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTexture2Convert *)  ((SoHeightMapToNormalMap *) x));
}
static void *_p_SoTextureCoordinateDefaultTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinateDefault *) x));
}
static void *_p_SoTextureCoordinateEnvironmentTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinateEnvironment *) x));
}
static void *_p_SoTextureCoordinateNormalMapTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinateNormalMap *) x));
}
static void *_p_SoTextureCoordinateObjectTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinateObject *) x));
}
static void *_p_SoTextureCoordinatePlaneTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinatePlane *) x));
}
static void *_p_SoTextureCoordinateReflectionMapTo_p_SoTextureCoordinateFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTextureCoordinateFunction *)  ((SoTextureCoordinateReflectionMap *) x));
}
static void *_p_SoAlarmSensorTo_p_SoTimerQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTimerQueueSensor *)  ((SoAlarmSensor *) x));
}
static void *_p_SoTimerSensorTo_p_SoTimerQueueSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTimerQueueSensor *)  ((SoTimerSensor *) x));
}
static void *_p_SoToVRML2ActionTo_p_SoToVRMLAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoToVRMLAction *)  ((SoToVRML2Action *) x));
}
static void *_p_SoCenterballManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoCenterballManip *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoHandleBoxManip *) x));
}
static void *_p_SoJackManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoJackManip *) x));
}
static void *_p_SoTabBoxManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoTabBoxManip *) x));
}
static void *_p_SoTrackballManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoTrackballManip *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *)  ((SoTransformManip *) x));
}
static void *_p_SoTransformerManipTo_p_SoTransform(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransform *) (SoTransformManip *) ((SoTransformerManip *) x));
}
static void *_p_SoCenterballManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoCenterballManip *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoHandleBoxManip *) x));
}
static void *_p_SoJackManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoJackManip *) x));
}
static void *_p_SoTabBoxManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoTabBoxManip *) x));
}
static void *_p_SoTrackballManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoTrackballManip *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformerManipTo_p_SoTransformManip(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformManip *)  ((SoTransformerManip *) x));
}
static void *_p_SoAntiSquishTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoAntiSquish *) x));
}
static void *_p_SoCenterballManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoCenterballManip *) x));
}
static void *_p_SoGeoLocationTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoGeoLocation *) x));
}
static void *_p_SoHandleBoxManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoHandleBoxManip *) x));
}
static void *_p_SoJackManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoJackManip *) x));
}
static void *_p_SoMatrixTransformTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoMatrixTransform *) x));
}
static void *_p_SoPendulumTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoRotation *) ((SoPendulum *) x));
}
static void *_p_SoResetTransformTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoResetTransform *) x));
}
static void *_p_SoRotationTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoRotation *) x));
}
static void *_p_SoRotationXYZTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoRotationXYZ *) x));
}
static void *_p_SoRotorTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoRotation *) ((SoRotor *) x));
}
static void *_p_SoScaleTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoScale *) x));
}
static void *_p_SoShuttleTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTranslation *) ((SoShuttle *) x));
}
static void *_p_SoSurroundScaleTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoSurroundScale *) x));
}
static void *_p_SoTabBoxManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoTabBoxManip *) x));
}
static void *_p_SoTrackballManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoTrackballManip *) x));
}
static void *_p_SoTransformTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoTransform *) x));
}
static void *_p_SoTransformBoxManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoTransformBoxManip *) x));
}
static void *_p_SoTransformManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *) ((SoTransformManip *) x));
}
static void *_p_SoTransformerManipTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *) (SoTransform *)(SoTransformManip *) ((SoTransformerManip *) x));
}
static void *_p_SoTranslationTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoTranslation *) x));
}
static void *_p_SoUnitsTo_p_SoTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTransformation *)  ((SoUnits *) x));
}
static void *_p_SoShuttleTo_p_SoTranslation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoTranslation *)  ((SoShuttle *) x));
}
static void *_p_SoShaderParameter1fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter1f *) x));
}
static void *_p_SoShaderParameter1iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter1i *) x));
}
static void *_p_SoShaderParameter2fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter2f *) x));
}
static void *_p_SoShaderParameter2iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter2i *) x));
}
static void *_p_SoShaderParameter3fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter3f *) x));
}
static void *_p_SoShaderParameter3iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter3i *) x));
}
static void *_p_SoShaderParameter4fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter4f *) x));
}
static void *_p_SoShaderParameter4iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameter4i *) x));
}
static void *_p_SoShaderParameterArray1fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray1f *) x));
}
static void *_p_SoShaderParameterArray1iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray1i *) x));
}
static void *_p_SoShaderParameterArray2fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray2f *) x));
}
static void *_p_SoShaderParameterArray2iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray2i *) x));
}
static void *_p_SoShaderParameterArray3fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray3f *) x));
}
static void *_p_SoShaderParameterArray3iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray3i *) x));
}
static void *_p_SoShaderParameterArray4fTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray4f *) x));
}
static void *_p_SoShaderParameterArray4iTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterArray4i *) x));
}
static void *_p_SoShaderParameterMatrixTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterMatrix *) x));
}
static void *_p_SoShaderParameterMatrixArrayTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderParameterMatrixArray *) x));
}
static void *_p_SoShaderStateMatrixParameterTo_p_SoUniformShaderParameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoUniformShaderParameter *)  ((SoShaderStateMatrixParameter *) x));
}
static void *_p_SoVRMLCylinderSensorTo_p_SoVRMLDragSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLDragSensor *)  ((SoVRMLCylinderSensor *) x));
}
static void *_p_SoVRMLPlaneSensorTo_p_SoVRMLDragSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLDragSensor *)  ((SoVRMLPlaneSensor *) x));
}
static void *_p_SoVRMLSphereSensorTo_p_SoVRMLDragSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLDragSensor *)  ((SoVRMLSphereSensor *) x));
}
static void *_p_SoVRMLBoxTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLBox *) x));
}
static void *_p_SoVRMLConeTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLCone *) x));
}
static void *_p_SoVRMLCylinderTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLCylinder *) x));
}
static void *_p_SoVRMLElevationGridTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLElevationGrid *) x));
}
static void *_p_SoVRMLExtrusionTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLExtrusion *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *) (SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *) (SoVRMLVertexLine *) ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *) (SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *) (SoVRMLVertexShape *) ((SoVRMLIndexedShape *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *) (SoVRMLVertexPoint *) ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLSphereTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLSphere *) x));
}
static void *_p_SoVRMLTextTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLText *) x));
}
static void *_p_SoVRMLVertexLineTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLVertexLine *) x));
}
static void *_p_SoVRMLVertexPointTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLVertexPoint *) x));
}
static void *_p_SoVRMLVertexShapeTo_p_SoVRMLGeometry(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGeometry *)  ((SoVRMLVertexShape *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoVRMLGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGroup *)  ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLTransformTo_p_SoVRMLGroup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLGroup *)  ((SoVRMLTransform *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoVRMLIndexedLine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLIndexedLine *)  ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoVRMLIndexedShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLIndexedShape *)  ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLColorInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLColorInterpolator *) x));
}
static void *_p_SoVRMLCoordinateInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLCoordinateInterpolator *) x));
}
static void *_p_SoVRMLNormalInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLNormalInterpolator *) x));
}
static void *_p_SoVRMLOrientationInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLOrientationInterpolator *) x));
}
static void *_p_SoVRMLPositionInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLPositionInterpolator *) x));
}
static void *_p_SoVRMLScalarInterpolatorTo_p_SoVRMLInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLInterpolator *)  ((SoVRMLScalarInterpolator *) x));
}
static void *_p_SoVRMLDirectionalLightTo_p_SoVRMLLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLLight *)  ((SoVRMLDirectionalLight *) x));
}
static void *_p_SoVRMLPointLightTo_p_SoVRMLLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLLight *)  ((SoVRMLPointLight *) x));
}
static void *_p_SoVRMLSpotLightTo_p_SoVRMLLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLLight *)  ((SoVRMLSpotLight *) x));
}
static void *_p_SoVRMLAnchorTo_p_SoVRMLParent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLParent *)  ((SoVRMLAnchor *) x));
}
static void *_p_SoVRMLBillboardTo_p_SoVRMLParent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLParent *)  ((SoVRMLBillboard *) x));
}
static void *_p_SoVRMLCollisionTo_p_SoVRMLParent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLParent *) (SoVRMLGroup *) ((SoVRMLCollision *) x));
}
static void *_p_SoVRMLGroupTo_p_SoVRMLParent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLParent *)  ((SoVRMLGroup *) x));
}
static void *_p_SoVRMLTransformTo_p_SoVRMLParent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLParent *) (SoVRMLGroup *) ((SoVRMLTransform *) x));
}
static void *_p_SoVRMLCylinderSensorTo_p_SoVRMLSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLSensor *) (SoVRMLDragSensor *) ((SoVRMLCylinderSensor *) x));
}
static void *_p_SoVRMLDragSensorTo_p_SoVRMLSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLSensor *)  ((SoVRMLDragSensor *) x));
}
static void *_p_SoVRMLPlaneSensorTo_p_SoVRMLSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLSensor *) (SoVRMLDragSensor *) ((SoVRMLPlaneSensor *) x));
}
static void *_p_SoVRMLSphereSensorTo_p_SoVRMLSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLSensor *) (SoVRMLDragSensor *) ((SoVRMLSphereSensor *) x));
}
static void *_p_SoVRMLImageTextureTo_p_SoVRMLTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLTexture *)  ((SoVRMLImageTexture *) x));
}
static void *_p_SoVRMLMovieTextureTo_p_SoVRMLTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLTexture *)  ((SoVRMLMovieTexture *) x));
}
static void *_p_SoVRMLPixelTextureTo_p_SoVRMLTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLTexture *)  ((SoVRMLPixelTexture *) x));
}
static void *_p_SoVRMLIndexedLineTo_p_SoVRMLVertexLine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLVertexLine *)  ((SoVRMLIndexedLine *) x));
}
static void *_p_SoVRMLIndexedLineSetTo_p_SoVRMLVertexLine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLVertexLine *) (SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet *) x));
}
static void *_p_SoVRMLPointSetTo_p_SoVRMLVertexPoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLVertexPoint *)  ((SoVRMLPointSet *) x));
}
static void *_p_SoVRMLIndexedFaceSetTo_p_SoVRMLVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLVertexShape *) (SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet *) x));
}
static void *_p_SoVRMLIndexedShapeTo_p_SoVRMLVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVRMLVertexShape *)  ((SoVRMLIndexedShape *) x));
}
static void *_p_SoPSVectorOutputTo_p_SoVectorOutput(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVectorOutput *)  ((SoPSVectorOutput *) x));
}
static void *_p_SoVectorizePSActionTo_p_SoVectorizeAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVectorizeAction *)  ((SoVectorizePSAction *) x));
}
static void *_p_SoGLVertexAttributeElementTo_p_SoVertexAttributeElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexAttributeElement *)  ((SoGLVertexAttributeElement *) x));
}
static void *_p_SoFaceSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *) ((SoFaceSet *) x));
}
static void *_p_SoIndexedFaceSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoIndexedShape *) ((SoIndexedFaceSet *) x));
}
static void *_p_SoIndexedLineSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoIndexedShape *) ((SoIndexedLineSet *) x));
}
static void *_p_SoIndexedMarkerSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet *) x));
}
static void *_p_SoIndexedPointSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoIndexedShape *) ((SoIndexedPointSet *) x));
}
static void *_p_SoIndexedShapeTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *)  ((SoIndexedShape *) x));
}
static void *_p_SoIndexedTriangleStripSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoIndexedShape *) ((SoIndexedTriangleStripSet *) x));
}
static void *_p_SoLineSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *) ((SoLineSet *) x));
}
static void *_p_SoMarkerSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet *) x));
}
static void *_p_SoNonIndexedShapeTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *)  ((SoNonIndexedShape *) x));
}
static void *_p_SoPointSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *) ((SoPointSet *) x));
}
static void *_p_SoQuadMeshTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *) ((SoQuadMesh *) x));
}
static void *_p_SoTriangleStripSetTo_p_SoVertexShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoVertexShape *) (SoNonIndexedShape *) ((SoTriangleStripSet *) x));
}
static void *_p_SoGLViewingMatrixElementTo_p_SoViewingMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoViewingMatrixElement *)  ((SoGLViewingMatrixElement *) x));
}
static void *_p_SoGLViewportRegionElementTo_p_SoViewportRegionElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoViewportRegionElement *)  ((SoGLViewportRegionElement *) x));
}
static void *_p_a_4__a_4__doublepTo_p_a_4__a_4__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[4][4])  ((doublep (*)[4][4]) x));
}
static void *_p_a_4__a_4__floatpTo_p_a_4__a_4__float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float (*)[4][4])  ((floatp (*)[4][4]) x));
}
static void *_p_charpTo_p_char(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((char *)  ((charp *) x));
}
static void *_p_f_char__charpTo_p_f_char__char(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((char (*)(char))  ((charp (*)(char)) x));
}
static void *_p_f_float_p_void__intpTo_p_f_float_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(float,void *))  ((intp (*)(float,void *)) x));
}
static void *_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intpTo_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(SoState *,SbVec3s const &,unsigned char *,enum SoGLImage::ResizeReason,void *,SoGLImage *))  ((intp (*)(SoState *,SbVec3s const &,unsigned char *,enum SoGLImage::ResizeReason,void *,SoGLImage *)) x));
}
static void *_p_f_p_void__floatpTo_p_f_p_void__float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float (*)(void *))  ((floatp (*)(void *)) x));
}
static void *_p_f_p_void__intpTo_p_f_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *))  ((intp (*)(void *)) x));
}
static void *_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intpTo_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,long,int,SoVRMLAudioClip *,void *))  ((intp (*)(void *,long,int,SoVRMLAudioClip *,void *)) x));
}
static void *_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *))  ((intp (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *)) x));
}
static void *_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *))  ((intp (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)) x));
}
static void *_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *,SoPrimitiveVertex const *))  ((intp (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)) x));
}
static void *_p_f_p_void_p_SoGLRenderAction__floatpTo_p_f_p_void_p_SoGLRenderAction__float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float (*)(void *,SoGLRenderAction *))  ((floatp (*)(void *,SoGLRenderAction *)) x));
}
static void *_p_f_p_void_p_SoVRMLAudioClip_p_void__intpTo_p_f_p_void_p_SoVRMLAudioClip_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,SoVRMLAudioClip *,void *))  ((intp (*)(void *,SoVRMLAudioClip *,void *)) x));
}
static void *_p_f_p_void_p_SoVRMLAudioClip_p_void__longpTo_p_f_p_void_p_SoVRMLAudioClip_p_void__long(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((long (*)(void *,SoVRMLAudioClip *,void *))  ((longp (*)(void *,SoVRMLAudioClip *,void *)) x));
}
static void *_p_f_p_void_p_q_const__SoPath__p_SoFullPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPath const *))  ((SoFullPath *(*)(void *,SoPath const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPath__p_SoNodeKitPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPath const *))  ((SoNodeKitPath *(*)(void *,SoPath const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPath__p_SoTempPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPath const *)) (SoFullPath *) ((SoTempPath *(*)(void *,SoPath const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intpTo_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,SoPath const *,SoPath const *))  ((intp (*)(void *,SoPath const *,SoPath const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPickedPoint const *))  ((SoFullPath *(*)(void *,SoPickedPoint const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPickedPoint const *))  ((SoNodeKitPath *(*)(void *,SoPickedPoint const *)) x));
}
static void *_p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath *(*)(void *,SoPickedPoint const *)) (SoFullPath *) ((SoTempPath *(*)(void *,SoPickedPoint const *)) x));
}
static void *_p_f_p_void_p_void__intpTo_p_f_p_void_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,void *))  ((intp (*)(void *,void *)) x));
}
static void *_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4fTo_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbVec4f &(*)(void *,SbVec3f const &,SbVec3f const &))  ((SbColor4f &(*)(void *,SbVec3f const &,SbVec3f const &)) x));
}
static void *_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intpTo_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *const,SbPlane const *const,int const))  ((intp (*)(void *const,SbPlane const *const,int const)) x));
}
static void *_p_f_q_const__p_void_r_q_const__SbBox3f__intpTo_p_f_q_const__p_void_r_q_const__SbBox3f__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *const,SbBox3f const &))  ((intp (*)(void *const,SbBox3f const &)) x));
}
static void *_p_f_q_const__p_void_r_q_const__SbSphere__intpTo_p_f_q_const__p_void_r_q_const__SbSphere__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *const,SbSphere const &))  ((intp (*)(void *const,SbSphere const &)) x));
}
static void *_p_f_q_const__p_void_r_q_const__SbVec3f__intpTo_p_f_q_const__p_void_r_q_const__SbVec3f__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *const,SbVec3f const &))  ((intp (*)(void *const,SbVec3f const &)) x));
}
static void *_p_f_r_q_const__SbName_float_int_p_void__intpTo_p_f_r_q_const__SbName_float_int_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(SbName const &,float,int,void *))  ((intp (*)(SbName const &,float,int,void *)) x));
}
static void *_p_f_r_q_const__SbString_p_SbImage_p_void__intpTo_p_f_r_q_const__SbString_p_SbImage_p_void__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(SbString const &,SbImage *,void *))  ((intp (*)(SbString const &,SbImage *,void *)) x));
}
static void *_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intpTo_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(SbString const &,void *,SoVRMLImageTexture *))  ((intp (*)(SbString const &,void *,SoVRMLImageTexture *)) x));
}
static void *_p_longpTo_p_long(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((long *)  ((longp *) x));
}
static void *_p_p_ScXMLAddOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLAddOpExprDataObj **) x));
}
static void *_p_p_ScXMLAndOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLAndOpExprDataObj **) x));
}
static void *_p_p_ScXMLAppendOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLAppendOpExprDataObj **) x));
}
static void *_p_p_ScXMLBoolDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLConstantDataObj *) ((ScXMLBoolDataObj **) x));
}
static void *_p_p_ScXMLCoinAddOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLAddOpExprDataObj *) ((ScXMLCoinAddOpExprDataObj **) x));
}
static void *_p_p_ScXMLCoinDivideOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLDivideOpExprDataObj *) ((ScXMLCoinDivideOpExprDataObj **) x));
}
static void *_p_p_ScXMLCoinEqualsOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLEqualsOpExprDataObj *) ((ScXMLCoinEqualsOpExprDataObj **) x));
}
static void *_p_p_ScXMLCoinLengthFuncExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLCoinLengthFuncExprDataObj **) x));
}
static void *_p_p_ScXMLCoinMultiplyOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLMultiplyOpExprDataObj *) ((ScXMLCoinMultiplyOpExprDataObj **) x));
}
static void *_p_p_ScXMLCoinSubtractOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLSubtractOpExprDataObj *) ((ScXMLCoinSubtractOpExprDataObj **) x));
}
static void *_p_p_ScXMLConstantDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **)  ((ScXMLConstantDataObj **) x));
}
static void *_p_p_ScXMLDivideOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLDivideOpExprDataObj **) x));
}
static void *_p_p_ScXMLEqualsOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLEqualsOpExprDataObj **) x));
}
static void *_p_p_ScXMLExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **)  ((ScXMLExprDataObj **) x));
}
static void *_p_p_ScXMLInExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *)(ScXMLMinimumExprDataObj *) ((ScXMLInExprDataObj **) x));
}
static void *_p_p_ScXMLMinimumExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLMinimumExprDataObj **) x));
}
static void *_p_p_ScXMLMultiplyOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLMultiplyOpExprDataObj **) x));
}
static void *_p_p_ScXMLNegateOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLNegateOpExprDataObj **) x));
}
static void *_p_p_ScXMLNotOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLNotOpExprDataObj **) x));
}
static void *_p_p_ScXMLOrOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLOrOpExprDataObj **) x));
}
static void *_p_p_ScXMLRealDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLConstantDataObj *) ((ScXMLRealDataObj **) x));
}
static void *_p_p_ScXMLReferenceDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLReferenceDataObj **) x));
}
static void *_p_p_ScXMLSbDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLConstantDataObj *) ((ScXMLSbDataObj **) x));
}
static void *_p_p_ScXMLStringDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLConstantDataObj *) ((ScXMLStringDataObj **) x));
}
static void *_p_p_ScXMLSubtractOpExprDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **) (ScXMLExprDataObj *) ((ScXMLSubtractOpExprDataObj **) x));
}
static void *_p_p_ScXMLXMLDataObjTo_p_p_ScXMLDataObj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ScXMLDataObj **)  ((ScXMLXMLDataObj **) x));
}
static void *_p_p_SoAlphaTestTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoAlphaTest **) x));
}
static void *_p_p_SoAnnotationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoAnnotation **) x));
}
static void *_p_p_SoAntiSquishTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoAntiSquish **) x));
}
static void *_p_p_SoAppearanceKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoAppearanceKit **) x));
}
static void *_p_p_SoArrayTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoArray **) x));
}
static void *_p_p_SoAsciiTextTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoAsciiText **) x));
}
static void *_p_p_SoBaseColorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoBaseColor **) x));
}
static void *_p_p_SoBaseKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoBaseKit **) x));
}
static void *_p_p_SoBlinkerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSwitch *) ((SoBlinker **) x));
}
static void *_p_p_SoBoolOperationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoBoolOperation **) x));
}
static void *_p_p_SoBumpMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoBumpMap **) x));
}
static void *_p_p_SoBumpMapCoordinateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoBumpMapCoordinate **) x));
}
static void *_p_p_SoBumpMapTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoBumpMapTransform **) x));
}
static void *_p_p_SoCacheHintTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoCacheHint **) x));
}
static void *_p_p_SoCalculatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoCalculator **) x));
}
static void *_p_p_SoCallbackTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoCallback **) x));
}
static void *_p_p_SoCameraTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoCamera **) x));
}
static void *_p_p_SoCameraKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoCameraKit **) x));
}
static void *_p_p_SoCenterballDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoCenterballDragger **) x));
}
static void *_p_p_SoCenterballManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoCenterballManip **) x));
}
static void *_p_p_SoClipPlaneTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoClipPlane **) x));
}
static void *_p_p_SoClipPlaneManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoClipPlane *) ((SoClipPlaneManip **) x));
}
static void *_p_p_SoColorIndexTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoColorIndex **) x));
}
static void *_p_p_SoComplexityTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoComplexity **) x));
}
static void *_p_p_SoComposeMatrixTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeMatrix **) x));
}
static void *_p_p_SoComposeRotationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeRotation **) x));
}
static void *_p_p_SoComposeRotationFromToTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeRotationFromTo **) x));
}
static void *_p_p_SoComposeVec2fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeVec2f **) x));
}
static void *_p_p_SoComposeVec3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeVec3f **) x));
}
static void *_p_p_SoComposeVec4fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComposeVec4f **) x));
}
static void *_p_p_SoComputeBoundingBoxTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoComputeBoundingBox **) x));
}
static void *_p_p_SoConcatenateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoConcatenate **) x));
}
static void *_p_p_SoConeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCone **) x));
}
static void *_p_p_SoCoordinate3To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoCoordinate3 **) x));
}
static void *_p_p_SoCoordinate4To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoCoordinate4 **) x));
}
static void *_p_p_SoCounterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoCounter **) x));
}
static void *_p_p_SoCubeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCube **) x));
}
static void *_p_p_SoCylinderTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoCylinder **) x));
}
static void *_p_p_SoDecomposeMatrixTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoDecomposeMatrix **) x));
}
static void *_p_p_SoDecomposeRotationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoDecomposeRotation **) x));
}
static void *_p_p_SoDecomposeVec2fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec2f **) x));
}
static void *_p_p_SoDecomposeVec3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec3f **) x));
}
static void *_p_p_SoDecomposeVec4fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoDecomposeVec4f **) x));
}
static void *_p_p_SoDepthBufferTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoDepthBuffer **) x));
}
static void *_p_p_SoDirectionalLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoDirectionalLight **) x));
}
static void *_p_p_SoDirectionalLightDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger **) x));
}
static void *_p_p_SoDirectionalLightManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *)(SoDirectionalLight *) ((SoDirectionalLightManip **) x));
}
static void *_p_p_SoDragPointDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDragPointDragger **) x));
}
static void *_p_p_SoDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *) ((SoDragger **) x));
}
static void *_p_p_SoDrawStyleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoDrawStyle **) x));
}
static void *_p_p_SoElapsedTimeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoElapsedTime **) x));
}
static void *_p_p_SoEngineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *) ((SoEngine **) x));
}
static void *_p_p_SoEnvironmentTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoEnvironment **) x));
}
static void *_p_p_SoEventCallbackTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoEventCallback **) x));
}
static void *_p_p_SoExtSelectionTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *)(SoSelection *) ((SoExtSelection **) x));
}
static void *_p_p_SoFaceSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet **) x));
}
static void *_p_p_SoFieldContainerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **)  ((SoFieldContainer **) x));
}
static void *_p_p_SoFieldConverterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoFieldConverter **) x));
}
static void *_p_p_SoFileTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoFile **) x));
}
static void *_p_p_SoFontTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoFont **) x));
}
static void *_p_p_SoFontStyleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoFont *) ((SoFontStyle **) x));
}
static void *_p_p_SoFragmentShaderTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderObject *) ((SoFragmentShader **) x));
}
static void *_p_p_SoFrustumCameraTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoFrustumCamera **) x));
}
static void *_p_p_SoFullPathTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoPath *) ((SoFullPath **) x));
}
static void *_p_p_SoGateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoGate **) x));
}
static void *_p_p_SoGeoCoordinateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoGeoCoordinate **) x));
}
static void *_p_p_SoGeoLocationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoGeoLocation **) x));
}
static void *_p_p_SoGeoOriginTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoGeoOrigin **) x));
}
static void *_p_p_SoGeoSeparatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoGeoSeparator **) x));
}
static void *_p_p_SoGroupTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoGroup **) x));
}
static void *_p_p_SoHandleBoxDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger **) x));
}
static void *_p_p_SoHandleBoxManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoHandleBoxManip **) x));
}
static void *_p_p_SoHeightMapToNormalMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoTexture2Convert *) ((SoHeightMapToNormalMap **) x));
}
static void *_p_p_SoImageTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoImage **) x));
}
static void *_p_p_SoIndexedFaceSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet **) x));
}
static void *_p_p_SoIndexedLineSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet **) x));
}
static void *_p_p_SoIndexedMarkerSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet **) x));
}
static void *_p_p_SoIndexedNurbsCurveTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoIndexedNurbsCurve **) x));
}
static void *_p_p_SoIndexedNurbsSurfaceTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoIndexedNurbsSurface **) x));
}
static void *_p_p_SoIndexedPointSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet **) x));
}
static void *_p_p_SoIndexedShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *) ((SoIndexedShape **) x));
}
static void *_p_p_SoIndexedTriangleStripSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet **) x));
}
static void *_p_p_SoInfoTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoInfo **) x));
}
static void *_p_p_SoInteractionKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoInteractionKit **) x));
}
static void *_p_p_SoInterpolateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoInterpolate **) x));
}
static void *_p_p_SoInterpolateFloatTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateFloat **) x));
}
static void *_p_p_SoInterpolateRotationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateRotation **) x));
}
static void *_p_p_SoInterpolateVec2fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec2f **) x));
}
static void *_p_p_SoInterpolateVec3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec3f **) x));
}
static void *_p_p_SoInterpolateVec4fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *)(SoInterpolate *) ((SoInterpolateVec4f **) x));
}
static void *_p_p_SoJackDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoJackDragger **) x));
}
static void *_p_p_SoJackManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoJackManip **) x));
}
static void *_p_p_SoLODTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoLOD **) x));
}
static void *_p_p_SoLabelTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoLabel **) x));
}
static void *_p_p_SoLevelOfDetailTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoLevelOfDetail **) x));
}
static void *_p_p_SoLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoLight **) x));
}
static void *_p_p_SoLightKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoLightKit **) x));
}
static void *_p_p_SoLightModelTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoLightModel **) x));
}
static void *_p_p_SoLineSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet **) x));
}
static void *_p_p_SoLinearProfileTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoProfile *) ((SoLinearProfile **) x));
}
static void *_p_p_SoListenerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoListener **) x));
}
static void *_p_p_SoLocateHighlightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoLocateHighlight **) x));
}
static void *_p_p_SoMarkerSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet **) x));
}
static void *_p_p_SoMaterialTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoMaterial **) x));
}
static void *_p_p_SoMaterialBindingTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoMaterialBinding **) x));
}
static void *_p_p_SoMatrixTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoMatrixTransform **) x));
}
static void *_p_p_SoMultipleCopyTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoMultipleCopy **) x));
}
static void *_p_p_SoNodeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *) ((SoNode **) x));
}
static void *_p_p_SoNodeEngineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoNodeEngine **) x));
}
static void *_p_p_SoNodeKitListPartTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoNodeKitListPart **) x));
}
static void *_p_p_SoNodeKitPathTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoPath *) ((SoNodeKitPath **) x));
}
static void *_p_p_SoNonIndexedShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *) ((SoNonIndexedShape **) x));
}
static void *_p_p_SoNormalTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoNormal **) x));
}
static void *_p_p_SoNormalBindingTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoNormalBinding **) x));
}
static void *_p_p_SoNurbsCurveTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoNurbsCurve **) x));
}
static void *_p_p_SoNurbsProfileTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoProfile *) ((SoNurbsProfile **) x));
}
static void *_p_p_SoNurbsSurfaceTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoNurbsSurface **) x));
}
static void *_p_p_SoOnOffTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoOnOff **) x));
}
static void *_p_p_SoOneShotTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoOneShot **) x));
}
static void *_p_p_SoOrthographicCameraTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoOrthographicCamera **) x));
}
static void *_p_p_SoPackedColorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoPackedColor **) x));
}
static void *_p_p_SoPathTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **)  ((SoPath **) x));
}
static void *_p_p_SoPathSwitchTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoPathSwitch **) x));
}
static void *_p_p_SoPendulumTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoRotation *) ((SoPendulum **) x));
}
static void *_p_p_SoPerspectiveCameraTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoCamera *) ((SoPerspectiveCamera **) x));
}
static void *_p_p_SoPickStyleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoPickStyle **) x));
}
static void *_p_p_SoPointLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoPointLight **) x));
}
static void *_p_p_SoPointLightDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoPointLightDragger **) x));
}
static void *_p_p_SoPointLightManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *)(SoPointLight *) ((SoPointLightManip **) x));
}
static void *_p_p_SoPointSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet **) x));
}
static void *_p_p_SoPolygonOffsetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoPolygonOffset **) x));
}
static void *_p_p_SoProfileTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoProfile **) x));
}
static void *_p_p_SoProfileCoordinate2To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoProfileCoordinate2 **) x));
}
static void *_p_p_SoProfileCoordinate3To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoProfileCoordinate3 **) x));
}
static void *_p_p_SoProtoTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoProto **) x));
}
static void *_p_p_SoProtoInstanceTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoProtoInstance **) x));
}
static void *_p_p_SoQuadMeshTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh **) x));
}
static void *_p_p_SoResetTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoResetTransform **) x));
}
static void *_p_p_SoReversePerspectiveCameraTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoCamera *)(SoPerspectiveCamera *) ((SoReversePerspectiveCamera **) x));
}
static void *_p_p_SoRotateCylindricalDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger **) x));
}
static void *_p_p_SoRotateDiscDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger **) x));
}
static void *_p_p_SoRotateSphericalDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger **) x));
}
static void *_p_p_SoRotationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoRotation **) x));
}
static void *_p_p_SoRotationXYZTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoRotationXYZ **) x));
}
static void *_p_p_SoRotorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoRotation *) ((SoRotor **) x));
}
static void *_p_p_SoScaleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoScale **) x));
}
static void *_p_p_SoScale1DraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale1Dragger **) x));
}
static void *_p_p_SoScale2DraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2Dragger **) x));
}
static void *_p_p_SoScale2UniformDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger **) x));
}
static void *_p_p_SoScaleUniformDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger **) x));
}
static void *_p_p_SoSceneKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoSceneKit **) x));
}
static void *_p_p_SoSceneTexture2To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoSceneTexture2 **) x));
}
static void *_p_p_SoSceneTextureCubeMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoSceneTextureCubeMap **) x));
}
static void *_p_p_SoSelectOneTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoSelectOne **) x));
}
static void *_p_p_SoSelectionTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *) ((SoSelection **) x));
}
static void *_p_p_SoSeparatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoSeparator **) x));
}
static void *_p_p_SoSeparatorKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *) ((SoSeparatorKit **) x));
}
static void *_p_p_SoShaderObjectTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoShaderObject **) x));
}
static void *_p_p_SoShaderParameterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoShaderParameter **) x));
}
static void *_p_p_SoShaderParameter1fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1f **) x));
}
static void *_p_p_SoShaderParameter1iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1i **) x));
}
static void *_p_p_SoShaderParameter2fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2f **) x));
}
static void *_p_p_SoShaderParameter2iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2i **) x));
}
static void *_p_p_SoShaderParameter3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3f **) x));
}
static void *_p_p_SoShaderParameter3iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3i **) x));
}
static void *_p_p_SoShaderParameter4fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4f **) x));
}
static void *_p_p_SoShaderParameter4iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4i **) x));
}
static void *_p_p_SoShaderParameterArray1fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1f **) x));
}
static void *_p_p_SoShaderParameterArray1iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1i **) x));
}
static void *_p_p_SoShaderParameterArray2fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2f **) x));
}
static void *_p_p_SoShaderParameterArray2iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2i **) x));
}
static void *_p_p_SoShaderParameterArray3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3f **) x));
}
static void *_p_p_SoShaderParameterArray3iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3i **) x));
}
static void *_p_p_SoShaderParameterArray4fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4f **) x));
}
static void *_p_p_SoShaderParameterArray4iTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4i **) x));
}
static void *_p_p_SoShaderParameterMatrixTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrix **) x));
}
static void *_p_p_SoShaderParameterMatrixArrayTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrixArray **) x));
}
static void *_p_p_SoShaderProgramTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoShaderProgram **) x));
}
static void *_p_p_SoShaderStateMatrixParameterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderStateMatrixParameter **) x));
}
static void *_p_p_SoShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoShape **) x));
}
static void *_p_p_SoShapeHintsTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoShapeHints **) x));
}
static void *_p_p_SoShapeKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoShapeKit **) x));
}
static void *_p_p_SoShuttleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTranslation *) ((SoShuttle **) x));
}
static void *_p_p_SoSphereTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoSphere **) x));
}
static void *_p_p_SoSpotLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *) ((SoSpotLight **) x));
}
static void *_p_p_SoSpotLightDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger **) x));
}
static void *_p_p_SoSpotLightManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoLight *)(SoSpotLight *) ((SoSpotLightManip **) x));
}
static void *_p_p_SoSurroundScaleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoSurroundScale **) x));
}
static void *_p_p_SoSwitchTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoSwitch **) x));
}
static void *_p_p_SoTabBoxDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger **) x));
}
static void *_p_p_SoTabBoxManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTabBoxManip **) x));
}
static void *_p_p_SoTabPlaneDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger **) x));
}
static void *_p_p_SoTempPathTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoPath *)(SoFullPath *) ((SoTempPath **) x));
}
static void *_p_p_SoText2To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoText2 **) x));
}
static void *_p_p_SoText3To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoText3 **) x));
}
static void *_p_p_SoTextureTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTexture **) x));
}
static void *_p_p_SoTexture2To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTexture2 **) x));
}
static void *_p_p_SoTexture2ConvertTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoTexture2Convert **) x));
}
static void *_p_p_SoTexture2TransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTexture2Transform **) x));
}
static void *_p_p_SoTexture3To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTexture3 **) x));
}
static void *_p_p_SoTexture3TransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTexture3Transform **) x));
}
static void *_p_p_SoTextureCombineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCombine **) x));
}
static void *_p_p_SoTextureCoordinate2To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinate2 **) x));
}
static void *_p_p_SoTextureCoordinate3To_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinate3 **) x));
}
static void *_p_p_SoTextureCoordinateBindingTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateBinding **) x));
}
static void *_p_p_SoTextureCoordinateCubeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateCube **) x));
}
static void *_p_p_SoTextureCoordinateCylinderTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateCylinder **) x));
}
static void *_p_p_SoTextureCoordinateDefaultTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateDefault **) x));
}
static void *_p_p_SoTextureCoordinateEnvironmentTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateEnvironment **) x));
}
static void *_p_p_SoTextureCoordinateFunctionTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateFunction **) x));
}
static void *_p_p_SoTextureCoordinateNormalMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateNormalMap **) x));
}
static void *_p_p_SoTextureCoordinateObjectTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateObject **) x));
}
static void *_p_p_SoTextureCoordinatePlaneTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinatePlane **) x));
}
static void *_p_p_SoTextureCoordinateReflectionMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTextureCoordinateFunction *) ((SoTextureCoordinateReflectionMap **) x));
}
static void *_p_p_SoTextureCoordinateSphereTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureCoordinateSphere **) x));
}
static void *_p_p_SoTextureCubeMapTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTexture *) ((SoTextureCubeMap **) x));
}
static void *_p_p_SoTextureMatrixTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureMatrixTransform **) x));
}
static void *_p_p_SoTextureScalePolicyTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureScalePolicy **) x));
}
static void *_p_p_SoTextureUnitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTextureUnit **) x));
}
static void *_p_p_SoTimeCounterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoTimeCounter **) x));
}
static void *_p_p_SoTrackballDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTrackballDragger **) x));
}
static void *_p_p_SoTrackballManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTrackballManip **) x));
}
static void *_p_p_SoTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoTransform **) x));
}
static void *_p_p_SoTransformBoxDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger **) x));
}
static void *_p_p_SoTransformBoxManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformBoxManip **) x));
}
static void *_p_p_SoTransformManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *) ((SoTransformManip **) x));
}
static void *_p_p_SoTransformSeparatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoTransformSeparator **) x));
}
static void *_p_p_SoTransformVec3fTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoTransformVec3f **) x));
}
static void *_p_p_SoTransformationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTransformation **) x));
}
static void *_p_p_SoTransformerDraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformerDragger **) x));
}
static void *_p_p_SoTransformerManipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformerManip **) x));
}
static void *_p_p_SoTranslate1DraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger **) x));
}
static void *_p_p_SoTranslate2DraggerTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger **) x));
}
static void *_p_p_SoTranslationTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoTranslation **) x));
}
static void *_p_p_SoTransparencyTypeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoTransparencyType **) x));
}
static void *_p_p_SoTriangleStripSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet **) x));
}
static void *_p_p_SoTriggerAnyTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoEngine *) ((SoTriggerAny **) x));
}
static void *_p_p_SoUniformShaderParameterTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderParameter *) ((SoUniformShaderParameter **) x));
}
static void *_p_p_SoUnitsTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoTransformation *) ((SoUnits **) x));
}
static void *_p_p_SoVRMLAnchorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLAnchor **) x));
}
static void *_p_p_SoVRMLAppearanceTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLAppearance **) x));
}
static void *_p_p_SoVRMLAudioClipTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLAudioClip **) x));
}
static void *_p_p_SoVRMLBackgroundTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLBackground **) x));
}
static void *_p_p_SoVRMLBillboardTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLBillboard **) x));
}
static void *_p_p_SoVRMLBoxTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLBox **) x));
}
static void *_p_p_SoVRMLCollisionTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision **) x));
}
static void *_p_p_SoVRMLColorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLColor **) x));
}
static void *_p_p_SoVRMLColorInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLColorInterpolator **) x));
}
static void *_p_p_SoVRMLConeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCone **) x));
}
static void *_p_p_SoVRMLCoordinateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLCoordinate **) x));
}
static void *_p_p_SoVRMLCoordinateInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator **) x));
}
static void *_p_p_SoVRMLCylinderTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLCylinder **) x));
}
static void *_p_p_SoVRMLCylinderSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLCylinderSensor **) x));
}
static void *_p_p_SoVRMLDirectionalLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLDirectionalLight **) x));
}
static void *_p_p_SoVRMLDragSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *) ((SoVRMLDragSensor **) x));
}
static void *_p_p_SoVRMLElevationGridTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLElevationGrid **) x));
}
static void *_p_p_SoVRMLExtrusionTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLExtrusion **) x));
}
static void *_p_p_SoVRMLFogTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLFog **) x));
}
static void *_p_p_SoVRMLFontStyleTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLFontStyle **) x));
}
static void *_p_p_SoVRMLGeometryTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoVRMLGeometry **) x));
}
static void *_p_p_SoVRMLGroupTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *) ((SoVRMLGroup **) x));
}
static void *_p_p_SoVRMLImageTextureTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLImageTexture **) x));
}
static void *_p_p_SoVRMLIndexedFaceSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet **) x));
}
static void *_p_p_SoVRMLIndexedLineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine **) x));
}
static void *_p_p_SoVRMLIndexedLineSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet **) x));
}
static void *_p_p_SoVRMLIndexedShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape **) x));
}
static void *_p_p_SoVRMLInlineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLInline **) x));
}
static void *_p_p_SoVRMLInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *) ((SoVRMLInterpolator **) x));
}
static void *_p_p_SoVRMLLODTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLLOD **) x));
}
static void *_p_p_SoVRMLLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLLight **) x));
}
static void *_p_p_SoVRMLMaterialTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLMaterial **) x));
}
static void *_p_p_SoVRMLMovieTextureTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLMovieTexture **) x));
}
static void *_p_p_SoVRMLNavigationInfoTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLNavigationInfo **) x));
}
static void *_p_p_SoVRMLNormalTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLNormal **) x));
}
static void *_p_p_SoVRMLNormalInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLNormalInterpolator **) x));
}
static void *_p_p_SoVRMLOrientationInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator **) x));
}
static void *_p_p_SoVRMLParentTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLParent **) x));
}
static void *_p_p_SoVRMLPixelTextureTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLTexture *) ((SoVRMLPixelTexture **) x));
}
static void *_p_p_SoVRMLPlaneSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLPlaneSensor **) x));
}
static void *_p_p_SoVRMLPointLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLPointLight **) x));
}
static void *_p_p_SoVRMLPointSetTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet **) x));
}
static void *_p_p_SoVRMLPositionInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLPositionInterpolator **) x));
}
static void *_p_p_SoVRMLProximitySensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLProximitySensor **) x));
}
static void *_p_p_SoVRMLScalarInterpolatorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLScalarInterpolator **) x));
}
static void *_p_p_SoVRMLScriptTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLScript **) x));
}
static void *_p_p_SoVRMLSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLSensor **) x));
}
static void *_p_p_SoVRMLShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLShape **) x));
}
static void *_p_p_SoVRMLSoundTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLSound **) x));
}
static void *_p_p_SoVRMLSphereTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLSphere **) x));
}
static void *_p_p_SoVRMLSphereSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLSphereSensor **) x));
}
static void *_p_p_SoVRMLSpotLightTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoVRMLLight *) ((SoVRMLSpotLight **) x));
}
static void *_p_p_SoVRMLSwitchTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *) ((SoVRMLSwitch **) x));
}
static void *_p_p_SoVRMLTextTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLText **) x));
}
static void *_p_p_SoVRMLTextureTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLTexture **) x));
}
static void *_p_p_SoVRMLTextureCoordinateTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLTextureCoordinate **) x));
}
static void *_p_p_SoVRMLTextureTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLTextureTransform **) x));
}
static void *_p_p_SoVRMLTimeSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoNodeEngine *) ((SoVRMLTimeSensor **) x));
}
static void *_p_p_SoVRMLTouchSensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLTouchSensor **) x));
}
static void *_p_p_SoVRMLTransformTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform **) x));
}
static void *_p_p_SoVRMLVertexLineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexLine **) x));
}
static void *_p_p_SoVRMLVertexPointTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexPoint **) x));
}
static void *_p_p_SoVRMLVertexShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexShape **) x));
}
static void *_p_p_SoVRMLViewpointTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLViewpoint **) x));
}
static void *_p_p_SoVRMLVisibilitySensorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLVisibilitySensor **) x));
}
static void *_p_p_SoVRMLWorldInfoTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVRMLWorldInfo **) x));
}
static void *_p_p_SoVertexAttributeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVertexAttribute **) x));
}
static void *_p_p_SoVertexAttributeBindingTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVertexAttributeBinding **) x));
}
static void *_p_p_SoVertexPropertyTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoVertexProperty **) x));
}
static void *_p_p_SoVertexShaderTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShaderObject *) ((SoVertexShader **) x));
}
static void *_p_p_SoVertexShapeTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoShape *) ((SoVertexShape **) x));
}
static void *_p_p_SoWWWAnchorTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoGroup *)(SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor **) x));
}
static void *_p_p_SoWWWInlineTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *) ((SoWWWInline **) x));
}
static void *_p_p_SoWrapperKitTo_p_p_SoBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoBase **) (SoFieldContainer *)(SoNode *)(SoBaseKit *)(SoSeparatorKit *) ((SoWrapperKit **) x));
}
static void *_p_p_SoBoolOperationTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoBoolOperation **) x));
}
static void *_p_p_SoCalculatorTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoCalculator **) x));
}
static void *_p_p_SoComposeMatrixTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeMatrix **) x));
}
static void *_p_p_SoComposeRotationTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeRotation **) x));
}
static void *_p_p_SoComposeRotationFromToTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeRotationFromTo **) x));
}
static void *_p_p_SoComposeVec2fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeVec2f **) x));
}
static void *_p_p_SoComposeVec3fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeVec3f **) x));
}
static void *_p_p_SoComposeVec4fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComposeVec4f **) x));
}
static void *_p_p_SoComputeBoundingBoxTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoComputeBoundingBox **) x));
}
static void *_p_p_SoConcatenateTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoConcatenate **) x));
}
static void *_p_p_SoCounterTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoCounter **) x));
}
static void *_p_p_SoDecomposeMatrixTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoDecomposeMatrix **) x));
}
static void *_p_p_SoDecomposeRotationTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoDecomposeRotation **) x));
}
static void *_p_p_SoDecomposeVec2fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoDecomposeVec2f **) x));
}
static void *_p_p_SoDecomposeVec3fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoDecomposeVec3f **) x));
}
static void *_p_p_SoDecomposeVec4fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoDecomposeVec4f **) x));
}
static void *_p_p_SoElapsedTimeTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoElapsedTime **) x));
}
static void *_p_p_SoFieldConverterTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoFieldConverter **) x));
}
static void *_p_p_SoGateTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoGate **) x));
}
static void *_p_p_SoHeightMapToNormalMapTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoTexture2Convert *) ((SoHeightMapToNormalMap **) x));
}
static void *_p_p_SoInterpolateTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoInterpolate **) x));
}
static void *_p_p_SoInterpolateFloatTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoInterpolate *) ((SoInterpolateFloat **) x));
}
static void *_p_p_SoInterpolateRotationTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoInterpolate *) ((SoInterpolateRotation **) x));
}
static void *_p_p_SoInterpolateVec2fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoInterpolate *) ((SoInterpolateVec2f **) x));
}
static void *_p_p_SoInterpolateVec3fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoInterpolate *) ((SoInterpolateVec3f **) x));
}
static void *_p_p_SoInterpolateVec4fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **) (SoInterpolate *) ((SoInterpolateVec4f **) x));
}
static void *_p_p_SoOnOffTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoOnOff **) x));
}
static void *_p_p_SoOneShotTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoOneShot **) x));
}
static void *_p_p_SoSelectOneTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoSelectOne **) x));
}
static void *_p_p_SoTexture2ConvertTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoTexture2Convert **) x));
}
static void *_p_p_SoTimeCounterTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoTimeCounter **) x));
}
static void *_p_p_SoTransformVec3fTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoTransformVec3f **) x));
}
static void *_p_p_SoTriggerAnyTo_p_p_SoEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoEngine **)  ((SoTriggerAny **) x));
}
static void *_p_p_SoMFBitMaskTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *)(SoMFEnum *) ((SoMFBitMask **) x));
}
static void *_p_p_SoMFBoolTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFBool **) x));
}
static void *_p_p_SoMFColorTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFColor **) x));
}
static void *_p_p_SoMFColorRGBATo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFColorRGBA **) x));
}
static void *_p_p_SoMFDoubleTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFDouble **) x));
}
static void *_p_p_SoMFEngineTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFEngine **) x));
}
static void *_p_p_SoMFEnumTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFEnum **) x));
}
static void *_p_p_SoMFFloatTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFFloat **) x));
}
static void *_p_p_SoMFInt32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFInt32 **) x));
}
static void *_p_p_SoMFMatrixTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFMatrix **) x));
}
static void *_p_p_SoMFNameTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFName **) x));
}
static void *_p_p_SoMFNodeTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFNode **) x));
}
static void *_p_p_SoMFPathTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFPath **) x));
}
static void *_p_p_SoMFPlaneTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFPlane **) x));
}
static void *_p_p_SoMFRotationTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFRotation **) x));
}
static void *_p_p_SoMFShortTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFShort **) x));
}
static void *_p_p_SoMFStringTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFString **) x));
}
static void *_p_p_SoMFTimeTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFTime **) x));
}
static void *_p_p_SoMFUInt32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFUInt32 **) x));
}
static void *_p_p_SoMFUShortTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFUShort **) x));
}
static void *_p_p_SoMFVec2bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec2b **) x));
}
static void *_p_p_SoMFVec2dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec2d **) x));
}
static void *_p_p_SoMFVec2fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec2f **) x));
}
static void *_p_p_SoMFVec2i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec2i32 **) x));
}
static void *_p_p_SoMFVec2sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec2s **) x));
}
static void *_p_p_SoMFVec3bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec3b **) x));
}
static void *_p_p_SoMFVec3dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec3d **) x));
}
static void *_p_p_SoMFVec3fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec3f **) x));
}
static void *_p_p_SoMFVec3i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec3i32 **) x));
}
static void *_p_p_SoMFVec3sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec3s **) x));
}
static void *_p_p_SoMFVec4bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4b **) x));
}
static void *_p_p_SoMFVec4dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4d **) x));
}
static void *_p_p_SoMFVec4fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4f **) x));
}
static void *_p_p_SoMFVec4i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4i32 **) x));
}
static void *_p_p_SoMFVec4sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4s **) x));
}
static void *_p_p_SoMFVec4ubTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4ub **) x));
}
static void *_p_p_SoMFVec4ui32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4ui32 **) x));
}
static void *_p_p_SoMFVec4usTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoMField *) ((SoMFVec4us **) x));
}
static void *_p_p_SoMFieldTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **)  ((SoMField **) x));
}
static void *_p_p_SoSFBitMaskTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *)(SoSFEnum *) ((SoSFBitMask **) x));
}
static void *_p_p_SoSFBoolTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBool **) x));
}
static void *_p_p_SoSFBox2dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox2d **) x));
}
static void *_p_p_SoSFBox2fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox2f **) x));
}
static void *_p_p_SoSFBox2i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox2i32 **) x));
}
static void *_p_p_SoSFBox2sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox2s **) x));
}
static void *_p_p_SoSFBox3dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox3d **) x));
}
static void *_p_p_SoSFBox3fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox3f **) x));
}
static void *_p_p_SoSFBox3i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox3i32 **) x));
}
static void *_p_p_SoSFBox3sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFBox3s **) x));
}
static void *_p_p_SoSFColorTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFColor **) x));
}
static void *_p_p_SoSFColorRGBATo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFColorRGBA **) x));
}
static void *_p_p_SoSFDoubleTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFDouble **) x));
}
static void *_p_p_SoSFEngineTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFEngine **) x));
}
static void *_p_p_SoSFEnumTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFEnum **) x));
}
static void *_p_p_SoSFFloatTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFFloat **) x));
}
static void *_p_p_SoSFImageTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFImage **) x));
}
static void *_p_p_SoSFImage3To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFImage3 **) x));
}
static void *_p_p_SoSFInt32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFInt32 **) x));
}
static void *_p_p_SoSFMatrixTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFMatrix **) x));
}
static void *_p_p_SoSFNameTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFName **) x));
}
static void *_p_p_SoSFNodeTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFNode **) x));
}
static void *_p_p_SoSFPathTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFPath **) x));
}
static void *_p_p_SoSFPlaneTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFPlane **) x));
}
static void *_p_p_SoSFRotationTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFRotation **) x));
}
static void *_p_p_SoSFShortTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFShort **) x));
}
static void *_p_p_SoSFStringTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFString **) x));
}
static void *_p_p_SoSFTimeTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFTime **) x));
}
static void *_p_p_SoSFTriggerTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFTrigger **) x));
}
static void *_p_p_SoSFUInt32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFUInt32 **) x));
}
static void *_p_p_SoSFUShortTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFUShort **) x));
}
static void *_p_p_SoSFVec2bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec2b **) x));
}
static void *_p_p_SoSFVec2dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec2d **) x));
}
static void *_p_p_SoSFVec2fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec2f **) x));
}
static void *_p_p_SoSFVec2i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec2i32 **) x));
}
static void *_p_p_SoSFVec2sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec2s **) x));
}
static void *_p_p_SoSFVec3bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec3b **) x));
}
static void *_p_p_SoSFVec3dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec3d **) x));
}
static void *_p_p_SoSFVec3fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec3f **) x));
}
static void *_p_p_SoSFVec3i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec3i32 **) x));
}
static void *_p_p_SoSFVec3sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec3s **) x));
}
static void *_p_p_SoSFVec4bTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4b **) x));
}
static void *_p_p_SoSFVec4dTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4d **) x));
}
static void *_p_p_SoSFVec4fTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4f **) x));
}
static void *_p_p_SoSFVec4i32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4i32 **) x));
}
static void *_p_p_SoSFVec4sTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4s **) x));
}
static void *_p_p_SoSFVec4ubTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4ub **) x));
}
static void *_p_p_SoSFVec4ui32To_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4ui32 **) x));
}
static void *_p_p_SoSFVec4usTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **) (SoSField *) ((SoSFVec4us **) x));
}
static void *_p_p_SoSFieldTo_p_p_SoField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoField **)  ((SoSField **) x));
}
static void *_p_p_SoBoxHighlightRenderActionTo_p_p_SoGLRenderAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGLRenderAction **)  ((SoBoxHighlightRenderAction **) x));
}
static void *_p_p_SoLineHighlightRenderActionTo_p_p_SoGLRenderAction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoGLRenderAction **)  ((SoLineHighlightRenderAction **) x));
}
static void *_p_p_SoAlphaTestTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoAlphaTest **) x));
}
static void *_p_p_SoAnnotationTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *) ((SoAnnotation **) x));
}
static void *_p_p_SoAntiSquishTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoAntiSquish **) x));
}
static void *_p_p_SoAppearanceKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoAppearanceKit **) x));
}
static void *_p_p_SoArrayTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoArray **) x));
}
static void *_p_p_SoAsciiTextTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoAsciiText **) x));
}
static void *_p_p_SoBaseColorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoBaseColor **) x));
}
static void *_p_p_SoBaseKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoBaseKit **) x));
}
static void *_p_p_SoBlinkerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSwitch *) ((SoBlinker **) x));
}
static void *_p_p_SoBumpMapTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoBumpMap **) x));
}
static void *_p_p_SoBumpMapCoordinateTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoBumpMapCoordinate **) x));
}
static void *_p_p_SoBumpMapTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoBumpMapTransform **) x));
}
static void *_p_p_SoCacheHintTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoCacheHint **) x));
}
static void *_p_p_SoCallbackTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoCallback **) x));
}
static void *_p_p_SoCameraTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoCamera **) x));
}
static void *_p_p_SoCameraKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoCameraKit **) x));
}
static void *_p_p_SoCenterballDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoCenterballDragger **) x));
}
static void *_p_p_SoCenterballManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoCenterballManip **) x));
}
static void *_p_p_SoClipPlaneTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoClipPlane **) x));
}
static void *_p_p_SoClipPlaneManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoClipPlane *) ((SoClipPlaneManip **) x));
}
static void *_p_p_SoColorIndexTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoColorIndex **) x));
}
static void *_p_p_SoComplexityTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoComplexity **) x));
}
static void *_p_p_SoConeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoCone **) x));
}
static void *_p_p_SoCoordinate3To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoCoordinate3 **) x));
}
static void *_p_p_SoCoordinate4To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoCoordinate4 **) x));
}
static void *_p_p_SoCubeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoCube **) x));
}
static void *_p_p_SoCylinderTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoCylinder **) x));
}
static void *_p_p_SoDepthBufferTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoDepthBuffer **) x));
}
static void *_p_p_SoDirectionalLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *) ((SoDirectionalLight **) x));
}
static void *_p_p_SoDirectionalLightDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDirectionalLightDragger **) x));
}
static void *_p_p_SoDirectionalLightManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *)(SoDirectionalLight *) ((SoDirectionalLightManip **) x));
}
static void *_p_p_SoDragPointDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoDragPointDragger **) x));
}
static void *_p_p_SoDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *) ((SoDragger **) x));
}
static void *_p_p_SoDrawStyleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoDrawStyle **) x));
}
static void *_p_p_SoEnvironmentTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoEnvironment **) x));
}
static void *_p_p_SoEventCallbackTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoEventCallback **) x));
}
static void *_p_p_SoExtSelectionTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *)(SoSelection *) ((SoExtSelection **) x));
}
static void *_p_p_SoFaceSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoFaceSet **) x));
}
static void *_p_p_SoFileTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoFile **) x));
}
static void *_p_p_SoFontTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoFont **) x));
}
static void *_p_p_SoFontStyleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoFont *) ((SoFontStyle **) x));
}
static void *_p_p_SoFragmentShaderTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderObject *) ((SoFragmentShader **) x));
}
static void *_p_p_SoFrustumCameraTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoCamera *) ((SoFrustumCamera **) x));
}
static void *_p_p_SoGeoCoordinateTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoGeoCoordinate **) x));
}
static void *_p_p_SoGeoLocationTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoGeoLocation **) x));
}
static void *_p_p_SoGeoOriginTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoGeoOrigin **) x));
}
static void *_p_p_SoGeoSeparatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *) ((SoGeoSeparator **) x));
}
static void *_p_p_SoGroupTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoGroup **) x));
}
static void *_p_p_SoHandleBoxDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoHandleBoxDragger **) x));
}
static void *_p_p_SoHandleBoxManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoHandleBoxManip **) x));
}
static void *_p_p_SoImageTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoImage **) x));
}
static void *_p_p_SoIndexedFaceSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedFaceSet **) x));
}
static void *_p_p_SoIndexedLineSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedLineSet **) x));
}
static void *_p_p_SoIndexedMarkerSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoIndexedShape *)(SoIndexedPointSet *) ((SoIndexedMarkerSet **) x));
}
static void *_p_p_SoIndexedNurbsCurveTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoIndexedNurbsCurve **) x));
}
static void *_p_p_SoIndexedNurbsSurfaceTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoIndexedNurbsSurface **) x));
}
static void *_p_p_SoIndexedPointSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedPointSet **) x));
}
static void *_p_p_SoIndexedShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *) ((SoIndexedShape **) x));
}
static void *_p_p_SoIndexedTriangleStripSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoIndexedShape *) ((SoIndexedTriangleStripSet **) x));
}
static void *_p_p_SoInfoTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoInfo **) x));
}
static void *_p_p_SoInteractionKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoInteractionKit **) x));
}
static void *_p_p_SoJackDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoJackDragger **) x));
}
static void *_p_p_SoJackManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoJackManip **) x));
}
static void *_p_p_SoLODTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoLOD **) x));
}
static void *_p_p_SoLabelTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoLabel **) x));
}
static void *_p_p_SoLevelOfDetailTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoLevelOfDetail **) x));
}
static void *_p_p_SoLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoLight **) x));
}
static void *_p_p_SoLightKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoLightKit **) x));
}
static void *_p_p_SoLightModelTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoLightModel **) x));
}
static void *_p_p_SoLineSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoLineSet **) x));
}
static void *_p_p_SoLinearProfileTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoProfile *) ((SoLinearProfile **) x));
}
static void *_p_p_SoListenerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoListener **) x));
}
static void *_p_p_SoLocateHighlightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *) ((SoLocateHighlight **) x));
}
static void *_p_p_SoMarkerSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *)(SoPointSet *) ((SoMarkerSet **) x));
}
static void *_p_p_SoMaterialTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoMaterial **) x));
}
static void *_p_p_SoMaterialBindingTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoMaterialBinding **) x));
}
static void *_p_p_SoMatrixTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoMatrixTransform **) x));
}
static void *_p_p_SoMultipleCopyTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoMultipleCopy **) x));
}
static void *_p_p_SoNodeEngineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoNodeEngine **) x));
}
static void *_p_p_SoNodeKitListPartTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoNodeKitListPart **) x));
}
static void *_p_p_SoNonIndexedShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *) ((SoNonIndexedShape **) x));
}
static void *_p_p_SoNormalTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoNormal **) x));
}
static void *_p_p_SoNormalBindingTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoNormalBinding **) x));
}
static void *_p_p_SoNurbsCurveTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoNurbsCurve **) x));
}
static void *_p_p_SoNurbsProfileTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoProfile *) ((SoNurbsProfile **) x));
}
static void *_p_p_SoNurbsSurfaceTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoNurbsSurface **) x));
}
static void *_p_p_SoOrthographicCameraTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoCamera *) ((SoOrthographicCamera **) x));
}
static void *_p_p_SoPackedColorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoPackedColor **) x));
}
static void *_p_p_SoPathSwitchTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoPathSwitch **) x));
}
static void *_p_p_SoPendulumTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoRotation *) ((SoPendulum **) x));
}
static void *_p_p_SoPerspectiveCameraTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoCamera *) ((SoPerspectiveCamera **) x));
}
static void *_p_p_SoPickStyleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoPickStyle **) x));
}
static void *_p_p_SoPointLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *) ((SoPointLight **) x));
}
static void *_p_p_SoPointLightDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoPointLightDragger **) x));
}
static void *_p_p_SoPointLightManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *)(SoPointLight *) ((SoPointLightManip **) x));
}
static void *_p_p_SoPointSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoPointSet **) x));
}
static void *_p_p_SoPolygonOffsetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoPolygonOffset **) x));
}
static void *_p_p_SoProfileTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoProfile **) x));
}
static void *_p_p_SoProfileCoordinate2To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoProfileCoordinate2 **) x));
}
static void *_p_p_SoProfileCoordinate3To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoProfileCoordinate3 **) x));
}
static void *_p_p_SoProtoTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoProto **) x));
}
static void *_p_p_SoProtoInstanceTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoProtoInstance **) x));
}
static void *_p_p_SoQuadMeshTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoQuadMesh **) x));
}
static void *_p_p_SoResetTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoResetTransform **) x));
}
static void *_p_p_SoReversePerspectiveCameraTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoCamera *)(SoPerspectiveCamera *) ((SoReversePerspectiveCamera **) x));
}
static void *_p_p_SoRotateCylindricalDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateCylindricalDragger **) x));
}
static void *_p_p_SoRotateDiscDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateDiscDragger **) x));
}
static void *_p_p_SoRotateSphericalDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoRotateSphericalDragger **) x));
}
static void *_p_p_SoRotationTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoRotation **) x));
}
static void *_p_p_SoRotationXYZTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoRotationXYZ **) x));
}
static void *_p_p_SoRotorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoRotation *) ((SoRotor **) x));
}
static void *_p_p_SoScaleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoScale **) x));
}
static void *_p_p_SoScale1DraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale1Dragger **) x));
}
static void *_p_p_SoScale2DraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2Dragger **) x));
}
static void *_p_p_SoScale2UniformDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScale2UniformDragger **) x));
}
static void *_p_p_SoScaleUniformDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoScaleUniformDragger **) x));
}
static void *_p_p_SoSceneKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoSceneKit **) x));
}
static void *_p_p_SoSceneTexture2To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoSceneTexture2 **) x));
}
static void *_p_p_SoSceneTextureCubeMapTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoSceneTextureCubeMap **) x));
}
static void *_p_p_SoSelectionTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *) ((SoSelection **) x));
}
static void *_p_p_SoSeparatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoSeparator **) x));
}
static void *_p_p_SoSeparatorKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *) ((SoSeparatorKit **) x));
}
static void *_p_p_SoShaderObjectTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoShaderObject **) x));
}
static void *_p_p_SoShaderParameterTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoShaderParameter **) x));
}
static void *_p_p_SoShaderParameter1fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1f **) x));
}
static void *_p_p_SoShaderParameter1iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter1i **) x));
}
static void *_p_p_SoShaderParameter2fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2f **) x));
}
static void *_p_p_SoShaderParameter2iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter2i **) x));
}
static void *_p_p_SoShaderParameter3fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3f **) x));
}
static void *_p_p_SoShaderParameter3iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter3i **) x));
}
static void *_p_p_SoShaderParameter4fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4f **) x));
}
static void *_p_p_SoShaderParameter4iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameter4i **) x));
}
static void *_p_p_SoShaderParameterArray1fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1f **) x));
}
static void *_p_p_SoShaderParameterArray1iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray1i **) x));
}
static void *_p_p_SoShaderParameterArray2fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2f **) x));
}
static void *_p_p_SoShaderParameterArray2iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray2i **) x));
}
static void *_p_p_SoShaderParameterArray3fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3f **) x));
}
static void *_p_p_SoShaderParameterArray3iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray3i **) x));
}
static void *_p_p_SoShaderParameterArray4fTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4f **) x));
}
static void *_p_p_SoShaderParameterArray4iTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterArray4i **) x));
}
static void *_p_p_SoShaderParameterMatrixTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrix **) x));
}
static void *_p_p_SoShaderParameterMatrixArrayTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderParameterMatrixArray **) x));
}
static void *_p_p_SoShaderProgramTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoShaderProgram **) x));
}
static void *_p_p_SoShaderStateMatrixParameterTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *)(SoUniformShaderParameter *) ((SoShaderStateMatrixParameter **) x));
}
static void *_p_p_SoShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoShape **) x));
}
static void *_p_p_SoShapeHintsTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoShapeHints **) x));
}
static void *_p_p_SoShapeKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoSeparatorKit *) ((SoShapeKit **) x));
}
static void *_p_p_SoShuttleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTranslation *) ((SoShuttle **) x));
}
static void *_p_p_SoSphereTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoSphere **) x));
}
static void *_p_p_SoSpotLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *) ((SoSpotLight **) x));
}
static void *_p_p_SoSpotLightDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoSpotLightDragger **) x));
}
static void *_p_p_SoSpotLightManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoLight *)(SoSpotLight *) ((SoSpotLightManip **) x));
}
static void *_p_p_SoSurroundScaleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoSurroundScale **) x));
}
static void *_p_p_SoSwitchTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoSwitch **) x));
}
static void *_p_p_SoTabBoxDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabBoxDragger **) x));
}
static void *_p_p_SoTabBoxManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTabBoxManip **) x));
}
static void *_p_p_SoTabPlaneDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTabPlaneDragger **) x));
}
static void *_p_p_SoText2To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoText2 **) x));
}
static void *_p_p_SoText3To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoText3 **) x));
}
static void *_p_p_SoTextureTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTexture **) x));
}
static void *_p_p_SoTexture2To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTexture *) ((SoTexture2 **) x));
}
static void *_p_p_SoTexture2TransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTexture2Transform **) x));
}
static void *_p_p_SoTexture3To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTexture *) ((SoTexture3 **) x));
}
static void *_p_p_SoTexture3TransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTexture3Transform **) x));
}
static void *_p_p_SoTextureCombineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCombine **) x));
}
static void *_p_p_SoTextureCoordinate2To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinate2 **) x));
}
static void *_p_p_SoTextureCoordinate3To_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinate3 **) x));
}
static void *_p_p_SoTextureCoordinateBindingTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinateBinding **) x));
}
static void *_p_p_SoTextureCoordinateCubeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinateCube **) x));
}
static void *_p_p_SoTextureCoordinateCylinderTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinateCylinder **) x));
}
static void *_p_p_SoTextureCoordinateDefaultTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinateDefault **) x));
}
static void *_p_p_SoTextureCoordinateEnvironmentTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinateEnvironment **) x));
}
static void *_p_p_SoTextureCoordinateFunctionTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinateFunction **) x));
}
static void *_p_p_SoTextureCoordinateNormalMapTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinateNormalMap **) x));
}
static void *_p_p_SoTextureCoordinateObjectTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinateObject **) x));
}
static void *_p_p_SoTextureCoordinatePlaneTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinatePlane **) x));
}
static void *_p_p_SoTextureCoordinateReflectionMapTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTextureCoordinateFunction *) ((SoTextureCoordinateReflectionMap **) x));
}
static void *_p_p_SoTextureCoordinateSphereTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureCoordinateSphere **) x));
}
static void *_p_p_SoTextureCubeMapTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTexture *) ((SoTextureCubeMap **) x));
}
static void *_p_p_SoTextureMatrixTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureMatrixTransform **) x));
}
static void *_p_p_SoTextureScalePolicyTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureScalePolicy **) x));
}
static void *_p_p_SoTextureUnitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTextureUnit **) x));
}
static void *_p_p_SoTrackballDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTrackballDragger **) x));
}
static void *_p_p_SoTrackballManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTrackballManip **) x));
}
static void *_p_p_SoTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoTransform **) x));
}
static void *_p_p_SoTransformBoxDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformBoxDragger **) x));
}
static void *_p_p_SoTransformBoxManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformBoxManip **) x));
}
static void *_p_p_SoTransformManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *) ((SoTransformManip **) x));
}
static void *_p_p_SoTransformSeparatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoTransformSeparator **) x));
}
static void *_p_p_SoTransformationTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTransformation **) x));
}
static void *_p_p_SoTransformerDraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTransformerDragger **) x));
}
static void *_p_p_SoTransformerManipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *)(SoTransform *)(SoTransformManip *) ((SoTransformerManip **) x));
}
static void *_p_p_SoTranslate1DraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate1Dragger **) x));
}
static void *_p_p_SoTranslate2DraggerTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoInteractionKit *)(SoDragger *) ((SoTranslate2Dragger **) x));
}
static void *_p_p_SoTranslationTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoTranslation **) x));
}
static void *_p_p_SoTransparencyTypeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoTransparencyType **) x));
}
static void *_p_p_SoTriangleStripSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVertexShape *)(SoNonIndexedShape *) ((SoTriangleStripSet **) x));
}
static void *_p_p_SoUniformShaderParameterTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderParameter *) ((SoUniformShaderParameter **) x));
}
static void *_p_p_SoUnitsTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoTransformation *) ((SoUnits **) x));
}
static void *_p_p_SoVRMLAnchorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoVRMLParent *) ((SoVRMLAnchor **) x));
}
static void *_p_p_SoVRMLAppearanceTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLAppearance **) x));
}
static void *_p_p_SoVRMLAudioClipTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLAudioClip **) x));
}
static void *_p_p_SoVRMLBackgroundTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLBackground **) x));
}
static void *_p_p_SoVRMLBillboardTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoVRMLParent *) ((SoVRMLBillboard **) x));
}
static void *_p_p_SoVRMLBoxTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLBox **) x));
}
static void *_p_p_SoVRMLCollisionTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLCollision **) x));
}
static void *_p_p_SoVRMLColorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLColor **) x));
}
static void *_p_p_SoVRMLColorInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLColorInterpolator **) x));
}
static void *_p_p_SoVRMLConeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLCone **) x));
}
static void *_p_p_SoVRMLCoordinateTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLCoordinate **) x));
}
static void *_p_p_SoVRMLCoordinateInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLCoordinateInterpolator **) x));
}
static void *_p_p_SoVRMLCylinderTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLCylinder **) x));
}
static void *_p_p_SoVRMLCylinderSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLCylinderSensor **) x));
}
static void *_p_p_SoVRMLDirectionalLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLLight *) ((SoVRMLDirectionalLight **) x));
}
static void *_p_p_SoVRMLDragSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLSensor *) ((SoVRMLDragSensor **) x));
}
static void *_p_p_SoVRMLElevationGridTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLElevationGrid **) x));
}
static void *_p_p_SoVRMLExtrusionTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLExtrusion **) x));
}
static void *_p_p_SoVRMLFogTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLFog **) x));
}
static void *_p_p_SoVRMLFontStyleTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLFontStyle **) x));
}
static void *_p_p_SoVRMLGeometryTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoVRMLGeometry **) x));
}
static void *_p_p_SoVRMLGroupTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoVRMLParent *) ((SoVRMLGroup **) x));
}
static void *_p_p_SoVRMLImageTextureTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLTexture *) ((SoVRMLImageTexture **) x));
}
static void *_p_p_SoVRMLIndexedFaceSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *)(SoVRMLIndexedShape *) ((SoVRMLIndexedFaceSet **) x));
}
static void *_p_p_SoVRMLIndexedLineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *) ((SoVRMLIndexedLine **) x));
}
static void *_p_p_SoVRMLIndexedLineSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexLine *)(SoVRMLIndexedLine *) ((SoVRMLIndexedLineSet **) x));
}
static void *_p_p_SoVRMLIndexedShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexShape *) ((SoVRMLIndexedShape **) x));
}
static void *_p_p_SoVRMLInlineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLInline **) x));
}
static void *_p_p_SoVRMLInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *) ((SoVRMLInterpolator **) x));
}
static void *_p_p_SoVRMLLODTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoVRMLLOD **) x));
}
static void *_p_p_SoVRMLLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLLight **) x));
}
static void *_p_p_SoVRMLMaterialTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLMaterial **) x));
}
static void *_p_p_SoVRMLMovieTextureTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLTexture *) ((SoVRMLMovieTexture **) x));
}
static void *_p_p_SoVRMLNavigationInfoTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLNavigationInfo **) x));
}
static void *_p_p_SoVRMLNormalTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLNormal **) x));
}
static void *_p_p_SoVRMLNormalInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLNormalInterpolator **) x));
}
static void *_p_p_SoVRMLOrientationInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLOrientationInterpolator **) x));
}
static void *_p_p_SoVRMLParentTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoVRMLParent **) x));
}
static void *_p_p_SoVRMLPixelTextureTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLTexture *) ((SoVRMLPixelTexture **) x));
}
static void *_p_p_SoVRMLPlaneSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLPlaneSensor **) x));
}
static void *_p_p_SoVRMLPointLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLLight *) ((SoVRMLPointLight **) x));
}
static void *_p_p_SoVRMLPointSetTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *)(SoVRMLVertexPoint *) ((SoVRMLPointSet **) x));
}
static void *_p_p_SoVRMLPositionInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLPositionInterpolator **) x));
}
static void *_p_p_SoVRMLProximitySensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLProximitySensor **) x));
}
static void *_p_p_SoVRMLScalarInterpolatorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *)(SoVRMLInterpolator *) ((SoVRMLScalarInterpolator **) x));
}
static void *_p_p_SoVRMLScriptTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLScript **) x));
}
static void *_p_p_SoVRMLSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLSensor **) x));
}
static void *_p_p_SoVRMLShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLShape **) x));
}
static void *_p_p_SoVRMLSoundTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLSound **) x));
}
static void *_p_p_SoVRMLSphereTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLSphere **) x));
}
static void *_p_p_SoVRMLSphereSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLSensor *)(SoVRMLDragSensor *) ((SoVRMLSphereSensor **) x));
}
static void *_p_p_SoVRMLSpotLightTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoVRMLLight *) ((SoVRMLSpotLight **) x));
}
static void *_p_p_SoVRMLSwitchTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *) ((SoVRMLSwitch **) x));
}
static void *_p_p_SoVRMLTextTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLText **) x));
}
static void *_p_p_SoVRMLTextureTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLTexture **) x));
}
static void *_p_p_SoVRMLTextureCoordinateTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLTextureCoordinate **) x));
}
static void *_p_p_SoVRMLTextureTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLTextureTransform **) x));
}
static void *_p_p_SoVRMLTimeSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoNodeEngine *) ((SoVRMLTimeSensor **) x));
}
static void *_p_p_SoVRMLTouchSensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLTouchSensor **) x));
}
static void *_p_p_SoVRMLTransformTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoVRMLParent *)(SoVRMLGroup *) ((SoVRMLTransform **) x));
}
static void *_p_p_SoVRMLVertexLineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexLine **) x));
}
static void *_p_p_SoVRMLVertexPointTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexPoint **) x));
}
static void *_p_p_SoVRMLVertexShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *)(SoVRMLGeometry *) ((SoVRMLVertexShape **) x));
}
static void *_p_p_SoVRMLViewpointTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLViewpoint **) x));
}
static void *_p_p_SoVRMLVisibilitySensorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLVisibilitySensor **) x));
}
static void *_p_p_SoVRMLWorldInfoTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVRMLWorldInfo **) x));
}
static void *_p_p_SoVertexAttributeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVertexAttribute **) x));
}
static void *_p_p_SoVertexAttributeBindingTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVertexAttributeBinding **) x));
}
static void *_p_p_SoVertexPropertyTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoVertexProperty **) x));
}
static void *_p_p_SoVertexShaderTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShaderObject *) ((SoVertexShader **) x));
}
static void *_p_p_SoVertexShapeTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoShape *) ((SoVertexShape **) x));
}
static void *_p_p_SoWWWAnchorTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoGroup *)(SoSeparator *)(SoLocateHighlight *) ((SoWWWAnchor **) x));
}
static void *_p_p_SoWWWInlineTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **)  ((SoWWWInline **) x));
}
static void *_p_p_SoWrapperKitTo_p_p_SoNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoNode **) (SoBaseKit *)(SoSeparatorKit *) ((SoWrapperKit **) x));
}
static void *_p_p_SoFullPathTo_p_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath **)  ((SoFullPath **) x));
}
static void *_p_p_SoNodeKitPathTo_p_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath **)  ((SoNodeKitPath **) x));
}
static void *_p_p_SoTempPathTo_p_p_SoPath(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoPath **) (SoFullPath *) ((SoTempPath **) x));
}
static void *_p_p_floatpTo_p_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float **)  ((floatp **) x));
}
static void *_p_p_intpTo_p_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int **)  ((intp **) x));
}
static swig_type_info _swigt__p_AttributeApplyFunc = {"_p_AttributeApplyFunc", "AttributeApplyFunc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContextDestructionCB = {"_p_ContextDestructionCB", "ContextDestructionCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Key = {"_p_Key", "Key *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProgressCallbackType = {"_p_ProgressCallbackType", "ProgressCallbackType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBSPTree = {"_p_SbBSPTree", "SbBSPTree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBarrier = {"_p_SbBarrier", "SbBarrier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox2d = {"_p_SbBox2d", "SbBox2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox2f = {"_p_SbBox2f", "SbBox2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox2i32 = {"_p_SbBox2i32", "SbBox2i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox2s = {"_p_SbBox2s", "SbBox2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox3d = {"_p_SbBox3d", "SbBox3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox3f = {"_p_SbBox3f", "SbBox3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox3i32 = {"_p_SbBox3i32", "SbBox3i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbBox3s = {"_p_SbBox3s", "SbBox3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbByteBuffer = {"_p_SbByteBuffer", "SbByteBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbClip = {"_p_SbClip", "SbClip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbColor = {"_p_SbColor", "SbColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbColor4f = {"_p_SbColor4f", "SbColorRGBA *|SbColor4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCondVar = {"_p_SbCondVar", "SbCondVar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCylinder = {"_p_SbCylinder", "SbCylinder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCylinderPlaneProjector = {"_p_SbCylinderPlaneProjector", "SbCylinderPlaneProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCylinderProjector = {"_p_SbCylinderProjector", "SbCylinderProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCylinderSectionProjector = {"_p_SbCylinderSectionProjector", "SbCylinderSectionProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbCylinderSheetProjector = {"_p_SbCylinderSheetProjector", "SbCylinderSheetProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDPLine = {"_p_SbDPLine", "SbDPLine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDPMatrix = {"_p_SbDPMatrix", "SbMatrixd *|SbDPMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDPPlane = {"_p_SbDPPlane", "SbDPPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDPRotation = {"_p_SbDPRotation", "SbRotationd *|SbDPRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDPViewVolume = {"_p_SbDPViewVolume", "SbDPViewVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbDict = {"_p_SbDict", "SbDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbFifo = {"_p_SbFifo", "SbFifo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbHeap = {"_p_SbHeap", "SbHeap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbHeapFuncs = {"_p_SbHeapFuncs", "SbHeapFuncs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbImage = {"_p_SbImage", "SbImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbIntList = {"_p_SbIntList", "SbIntList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbLine = {"_p_SbLine", "SbLine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbLineProjector = {"_p_SbLineProjector", "SbLineProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbListT_SbString_t = {"_p_SbListT_SbString_t", "SbList< SbString > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbListT_char_const_p_t = {"_p_SbListT_char_const_p_t", "SbList< char const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbListT_int_t = {"_p_SbListT_int_t", "SbList< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbListT_void_p_t = {"_p_SbListT_void_p_t", "SbList< void * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbMatrix = {"_p_SbMatrix", "SbMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbMutex = {"_p_SbMutex", "SbMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbName = {"_p_SbName", "SbName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbOctTree = {"_p_SbOctTree", "SbOctTree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbOctTreeFuncs = {"_p_SbOctTreeFuncs", "SbOctTreeFuncs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbPList = {"_p_SbPList", "SbPList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbPlane = {"_p_SbPlane", "SbPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbPlaneProjector = {"_p_SbPlaneProjector", "SbPlaneProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbProjector = {"_p_SbProjector", "SbProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbRWMutex = {"_p_SbRWMutex", "SbRWMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbRotation = {"_p_SbRotation", "SbRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbSphere = {"_p_SbSphere", "SbSphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbSpherePlaneProjector = {"_p_SbSpherePlaneProjector", "SbSpherePlaneProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbSphereProjector = {"_p_SbSphereProjector", "SbSphereProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbSphereSectionProjector = {"_p_SbSphereSectionProjector", "SbSphereSectionProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbSphereSheetProjector = {"_p_SbSphereSheetProjector", "SbSphereSheetProjector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbStorage = {"_p_SbStorage", "SbStorage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbString = {"_p_SbString", "SbString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbStringList = {"_p_SbStringList", "SbStringList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbTesselator = {"_p_SbTesselator", "SbTesselator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbThread = {"_p_SbThread", "SbThread *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbThreadAutoLock = {"_p_SbThreadAutoLock", "SbThreadAutoLock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbThreadMutex = {"_p_SbThreadMutex", "SbThreadMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbTime = {"_p_SbTime", "SbTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2b = {"_p_SbVec2b", "SbVec2b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2d = {"_p_SbVec2d", "SbVec2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2f = {"_p_SbVec2f", "SbVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2i32 = {"_p_SbVec2i32", "SbVec2i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2s = {"_p_SbVec2s", "SbVec2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2ub = {"_p_SbVec2ub", "SbVec2ub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2ui32 = {"_p_SbVec2ui32", "SbVec2ui32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec2us = {"_p_SbVec2us", "SbVec2us *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3b = {"_p_SbVec3b", "SbVec3b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3d = {"_p_SbVec3d", "SbVec3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3f = {"_p_SbVec3f", "SbVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3fList = {"_p_SbVec3fList", "SbVec3fList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3i32 = {"_p_SbVec3i32", "SbVec3i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3s = {"_p_SbVec3s", "SbVec3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3ub = {"_p_SbVec3ub", "SbVec3ub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3ui32 = {"_p_SbVec3ui32", "SbVec3ui32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec3us = {"_p_SbVec3us", "SbVec3us *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4b = {"_p_SbVec4b", "SbVec4b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4d = {"_p_SbVec4d", "SbVec4d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4f = {"_p_SbVec4f", "SbVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4i32 = {"_p_SbVec4i32", "SbVec4i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4s = {"_p_SbVec4s", "SbVec4s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4ub = {"_p_SbVec4ub", "SbVec4ub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4ui32 = {"_p_SbVec4ui32", "SbVec4ui32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbVec4us = {"_p_SbVec4us", "SbVec4us *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbViewVolume = {"_p_SbViewVolume", "SbViewVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbViewportRegion = {"_p_SbViewportRegion", "SbViewportRegion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SbXfBox3f = {"_p_SbXfBox3f", "SbXfBox3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXML = {"_p_ScXML", "ScXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAbstractStateElt = {"_p_ScXMLAbstractStateElt", "ScXMLAbstractStateElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAddOpExprDataObj = {"_p_ScXMLAddOpExprDataObj", "ScXMLAddOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAnchorElt = {"_p_ScXMLAnchorElt", "ScXMLAnchorElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAndOpExprDataObj = {"_p_ScXMLAndOpExprDataObj", "ScXMLAndOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAppendOpExprDataObj = {"_p_ScXMLAppendOpExprDataObj", "ScXMLAppendOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLAssignElt = {"_p_ScXMLAssignElt", "ScXMLAssignElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLBoolDataObj = {"_p_ScXMLBoolDataObj", "ScXMLBoolDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinAddOpExprDataObj = {"_p_ScXMLCoinAddOpExprDataObj", "ScXMLCoinAddOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinDivideOpExprDataObj = {"_p_ScXMLCoinDivideOpExprDataObj", "ScXMLCoinDivideOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinEqualsOpExprDataObj = {"_p_ScXMLCoinEqualsOpExprDataObj", "ScXMLCoinEqualsOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinEvaluator = {"_p_ScXMLCoinEvaluator", "ScXMLCoinEvaluator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinLengthFuncExprDataObj = {"_p_ScXMLCoinLengthFuncExprDataObj", "ScXMLCoinLengthFuncExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinMultiplyOpExprDataObj = {"_p_ScXMLCoinMultiplyOpExprDataObj", "ScXMLCoinMultiplyOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLCoinSubtractOpExprDataObj = {"_p_ScXMLCoinSubtractOpExprDataObj", "ScXMLCoinSubtractOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLConstantDataObj = {"_p_ScXMLConstantDataObj", "ScXMLConstantDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLContentElt = {"_p_ScXMLContentElt", "ScXMLContentElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLDataElt = {"_p_ScXMLDataElt", "ScXMLDataElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLDataModelElt = {"_p_ScXMLDataModelElt", "ScXMLDataModelElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLDataObj = {"_p_ScXMLDataObj", "ScXMLDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLDivideOpExprDataObj = {"_p_ScXMLDivideOpExprDataObj", "ScXMLDivideOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLDocument = {"_p_ScXMLDocument", "ScXMLDocument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLECMAScriptEvaluator = {"_p_ScXMLECMAScriptEvaluator", "ScXMLECMAScriptEvaluator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLElseElt = {"_p_ScXMLElseElt", "ScXMLElseElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLElseIfElt = {"_p_ScXMLElseIfElt", "ScXMLElseIfElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLElt = {"_p_ScXMLElt", "ScXMLElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEltReader = {"_p_ScXMLEltReader", "ScXMLEltReader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEqualsOpExprDataObj = {"_p_ScXMLEqualsOpExprDataObj", "ScXMLEqualsOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEvaluator = {"_p_ScXMLEvaluator", "ScXMLEvaluator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEvent = {"_p_ScXMLEvent", "ScXMLEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEventElt = {"_p_ScXMLEventElt", "ScXMLEventElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLEventTarget = {"_p_ScXMLEventTarget", "ScXMLEventTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLExecutableElt = {"_p_ScXMLExecutableElt", "ScXMLExecutableElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLExprDataObj = {"_p_ScXMLExprDataObj", "ScXMLExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLFinalElt = {"_p_ScXMLFinalElt", "ScXMLFinalElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLFinalizeElt = {"_p_ScXMLFinalizeElt", "ScXMLFinalizeElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLHistoryElt = {"_p_ScXMLHistoryElt", "ScXMLHistoryElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLIfElt = {"_p_ScXMLIfElt", "ScXMLIfElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLInExprDataObj = {"_p_ScXMLInExprDataObj", "ScXMLInExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLInitialElt = {"_p_ScXMLInitialElt", "ScXMLInitialElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLInvokeElt = {"_p_ScXMLInvokeElt", "ScXMLInvokeElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLLogElt = {"_p_ScXMLLogElt", "ScXMLLogElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLMinimumEvaluator = {"_p_ScXMLMinimumEvaluator", "ScXMLMinimumEvaluator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLMinimumExprDataObj = {"_p_ScXMLMinimumExprDataObj", "ScXMLMinimumExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLMultiplyOpExprDataObj = {"_p_ScXMLMultiplyOpExprDataObj", "ScXMLMultiplyOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLNegateOpExprDataObj = {"_p_ScXMLNegateOpExprDataObj", "ScXMLNegateOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLNotOpExprDataObj = {"_p_ScXMLNotOpExprDataObj", "ScXMLNotOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLObject = {"_p_ScXMLObject", "ScXMLObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLOnEntryElt = {"_p_ScXMLOnEntryElt", "ScXMLOnEntryElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLOnExitElt = {"_p_ScXMLOnExitElt", "ScXMLOnExitElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLOrOpExprDataObj = {"_p_ScXMLOrOpExprDataObj", "ScXMLOrOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLParallelElt = {"_p_ScXMLParallelElt", "ScXMLParallelElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLParamElt = {"_p_ScXMLParamElt", "ScXMLParamElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLRealDataObj = {"_p_ScXMLRealDataObj", "ScXMLRealDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLReferenceDataObj = {"_p_ScXMLReferenceDataObj", "ScXMLReferenceDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLSbDataObj = {"_p_ScXMLSbDataObj", "ScXMLSbDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLScriptElt = {"_p_ScXMLScriptElt", "ScXMLScriptElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLScxmlElt = {"_p_ScXMLScxmlElt", "ScXMLScxmlElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLSendElt = {"_p_ScXMLSendElt", "ScXMLSendElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLStateElt = {"_p_ScXMLStateElt", "ScXMLStateElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLStateMachine = {"_p_ScXMLStateMachine", "ScXMLStateMachine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLStringDataObj = {"_p_ScXMLStringDataObj", "ScXMLStringDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLSubtractOpExprDataObj = {"_p_ScXMLSubtractOpExprDataObj", "ScXMLSubtractOpExprDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLTransitionElt = {"_p_ScXMLTransitionElt", "ScXMLTransitionElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLValidateElt = {"_p_ScXMLValidateElt", "ScXMLValidateElt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLXMLDataObj = {"_p_ScXMLXMLDataObj", "ScXMLXMLDataObj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScXMLXPathEvaluator = {"_p_ScXMLXPathEvaluator", "ScXMLXPathEvaluator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAccumulatedElement = {"_p_SoAccumulatedElement", "SoAccumulatedElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAction = {"_p_SoAction", "SoAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoActionMethodList = {"_p_SoActionMethodList", "SoActionMethodList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAlarmSensor = {"_p_SoAlarmSensor", "SoAlarmSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAlphaTest = {"_p_SoAlphaTest", "SoAlphaTest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAmbientColorElement = {"_p_SoAmbientColorElement", "SoAmbientColorElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAnnoText3CharOrientElement = {"_p_SoAnnoText3CharOrientElement", "SoAnnoText3CharOrientElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAnnoText3FontSizeHintElement = {"_p_SoAnnoText3FontSizeHintElement", "SoAnnoText3FontSizeHintElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAnnoText3RenderPrintElement = {"_p_SoAnnoText3RenderPrintElement", "SoAnnoText3RenderPrintElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAnnotation = {"_p_SoAnnotation", "SoAnnotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAntiSquish = {"_p_SoAntiSquish", "SoAntiSquish *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAppearanceKit = {"_p_SoAppearanceKit", "SoAppearanceKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoArray = {"_p_SoArray", "SoArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAsciiText = {"_p_SoAsciiText", "SoAsciiText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAudioDevice = {"_p_SoAudioDevice", "SoAudioDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAudioRenderAction = {"_p_SoAudioRenderAction", "SoAudioRenderAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAuditorList = {"_p_SoAuditorList", "SoAuditorList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBBoxModelMatrixElement = {"_p_SoBBoxModelMatrixElement", "SoBBoxModelMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBase = {"_p_SoBase", "SoBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBaseColor = {"_p_SoBaseColor", "SoBaseColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBaseKit = {"_p_SoBaseKit", "SoBaseKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBaseList = {"_p_SoBaseList", "SoBaseList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBlinker = {"_p_SoBlinker", "SoBlinker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBoolOperation = {"_p_SoBoolOperation", "SoBoolOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBoundingBoxCache = {"_p_SoBoundingBoxCache", "SoBoundingBoxCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBoxHighlightRenderAction = {"_p_SoBoxHighlightRenderAction", "SoBoxHighlightRenderAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMap = {"_p_SoBumpMap", "SoBumpMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMapCoordinate = {"_p_SoBumpMapCoordinate", "SoBumpMapCoordinate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMapCoordinateElement = {"_p_SoBumpMapCoordinateElement", "SoBumpMapCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMapElement = {"_p_SoBumpMapElement", "SoBumpMapElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMapMatrixElement = {"_p_SoBumpMapMatrixElement", "SoBumpMapMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBumpMapTransform = {"_p_SoBumpMapTransform", "SoBumpMapTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoBundle = {"_p_SoBundle", "SoBundle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoButtonEvent = {"_p_SoButtonEvent", "SoButtonEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoByteStream = {"_p_SoByteStream", "SoByteStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCache = {"_p_SoCache", "SoCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCacheElement = {"_p_SoCacheElement", "SoCacheElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCacheHint = {"_p_SoCacheHint", "SoCacheHint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCacheHintElement = {"_p_SoCacheHintElement", "SoCacheHintElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCalculator = {"_p_SoCalculator", "SoCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCallback = {"_p_SoCallback", "SoCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCallbackAction = {"_p_SoCallbackAction", "SoCallbackAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCallbackActionCB = {"_p_SoCallbackActionCB", "SoCallbackActionCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCallbackList = {"_p_SoCallbackList", "SoCallbackList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCamera = {"_p_SoCamera", "SoCamera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCameraKit = {"_p_SoCameraKit", "SoCameraKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCenterballDragger = {"_p_SoCenterballDragger", "SoCenterballDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCenterballManip = {"_p_SoCenterballManip", "SoCenterballManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoChildList = {"_p_SoChildList", "SoChildList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoClipPlane = {"_p_SoClipPlane", "SoClipPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoClipPlaneElement = {"_p_SoClipPlaneElement", "SoClipPlaneElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoClipPlaneManip = {"_p_SoClipPlaneManip", "SoClipPlaneManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoColorIndex = {"_p_SoColorIndex", "SoColorIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoColorPacker = {"_p_SoColorPacker", "SoColorPacker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComplexity = {"_p_SoComplexity", "SoComplexity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComplexityElement = {"_p_SoComplexityElement", "SoComplexityElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComplexityTypeElement = {"_p_SoComplexityTypeElement", "SoComplexityTypeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeMatrix = {"_p_SoComposeMatrix", "SoComposeMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeRotation = {"_p_SoComposeRotation", "SoComposeRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeRotationFromTo = {"_p_SoComposeRotationFromTo", "SoComposeRotationFromTo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeVec2f = {"_p_SoComposeVec2f", "SoComposeVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeVec3f = {"_p_SoComposeVec3f", "SoComposeVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComposeVec4f = {"_p_SoComposeVec4f", "SoComposeVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoComputeBoundingBox = {"_p_SoComputeBoundingBox", "SoComputeBoundingBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoConcatenate = {"_p_SoConcatenate", "SoConcatenate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCone = {"_p_SoCone", "SoCone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoConeDetail = {"_p_SoConeDetail", "SoConeDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoContextHandler = {"_p_SoContextHandler", "SoContextHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoConvexDataCache = {"_p_SoConvexDataCache", "SoConvexDataCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCoordinate3 = {"_p_SoCoordinate3", "SoCoordinate3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCoordinate4 = {"_p_SoCoordinate4", "SoCoordinate4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCoordinateElement = {"_p_SoCoordinateElement", "SoCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCounter = {"_p_SoCounter", "SoCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCreaseAngleElement = {"_p_SoCreaseAngleElement", "SoCreaseAngleElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCube = {"_p_SoCube", "SoCube *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCubeDetail = {"_p_SoCubeDetail", "SoCubeDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCullElement = {"_p_SoCullElement", "SoCullElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCylinder = {"_p_SoCylinder", "SoCylinder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoCylinderDetail = {"_p_SoCylinderDetail", "SoCylinderDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDB = {"_p_SoDB", "SoDB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDataSensor = {"_p_SoDataSensor", "SoDataSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDebugError = {"_p_SoDebugError", "SoDebugError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecimationPercentageElement = {"_p_SoDecimationPercentageElement", "SoDecimationPercentageElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecimationTypeElement = {"_p_SoDecimationTypeElement", "SoDecimationTypeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecomposeMatrix = {"_p_SoDecomposeMatrix", "SoDecomposeMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecomposeRotation = {"_p_SoDecomposeRotation", "SoDecomposeRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecomposeVec2f = {"_p_SoDecomposeVec2f", "SoDecomposeVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecomposeVec3f = {"_p_SoDecomposeVec3f", "SoDecomposeVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDecomposeVec4f = {"_p_SoDecomposeVec4f", "SoDecomposeVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDelayQueueSensor = {"_p_SoDelayQueueSensor", "SoDelayQueueSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDepthBuffer = {"_p_SoDepthBuffer", "SoDepthBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDepthBufferElement = {"_p_SoDepthBufferElement", "SoDepthBufferElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDepthBufferElement__DepthWriteFunction = {"_p_SoDepthBufferElement__DepthWriteFunction", "SoDepthBufferElement::DepthWriteFunction *|enum SoDepthBufferElement::DepthWriteFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDetail = {"_p_SoDetail", "SoDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDetailList = {"_p_SoDetailList", "SoDetailList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDiffuseColorElement = {"_p_SoDiffuseColorElement", "SoDiffuseColorElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDirectionalLight = {"_p_SoDirectionalLight", "SoDirectionalLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDirectionalLightDragger = {"_p_SoDirectionalLightDragger", "SoDirectionalLightDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDirectionalLightManip = {"_p_SoDirectionalLightManip", "SoDirectionalLightManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDragPointDragger = {"_p_SoDragPointDragger", "SoDragPointDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDragger = {"_p_SoDragger", "SoDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDrawStyle = {"_p_SoDrawStyle", "SoDrawStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoDrawStyleElement = {"_p_SoDrawStyleElement", "SoDrawStyleElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoElapsedTime = {"_p_SoElapsedTime", "SoElapsedTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoElement = {"_p_SoElement", "SoElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEmissiveColorElement = {"_p_SoEmissiveColorElement", "SoEmissiveColorElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEnabledElementsList = {"_p_SoEnabledElementsList", "SoEnabledElementsList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEngine = {"_p_SoEngine", "SoEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEngineList = {"_p_SoEngineList", "SoEngineList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEngineOutput = {"_p_SoEngineOutput", "SoEngineOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEngineOutputData = {"_p_SoEngineOutputData", "SoEngineOutputData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEngineOutputList = {"_p_SoEngineOutputList", "SoEngineOutputList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEnvironment = {"_p_SoEnvironment", "SoEnvironment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEnvironmentElement = {"_p_SoEnvironmentElement", "SoEnvironmentElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoError = {"_p_SoError", "SoError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEvent = {"_p_SoEvent", "SoEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEventCallback = {"_p_SoEventCallback", "SoEventCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoEventManager = {"_p_SoEventManager", "SoEventManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoExtSelection = {"_p_SoExtSelection", "SoExtSelection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFaceDetail = {"_p_SoFaceDetail", "SoFaceDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFaceSet = {"_p_SoFaceSet", "SoFaceSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoField = {"_p_SoField", "SoField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFieldContainer = {"_p_SoFieldContainer", "SoFieldContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFieldConverter = {"_p_SoFieldConverter", "SoFieldConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFieldData = {"_p_SoFieldData", "SoFieldData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFieldList = {"_p_SoFieldList", "SoFieldList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFieldSensor = {"_p_SoFieldSensor", "SoFieldSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFile = {"_p_SoFile", "SoFile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFloatElement = {"_p_SoFloatElement", "SoFloatElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFocalDistanceElement = {"_p_SoFocalDistanceElement", "SoFocalDistanceElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFont = {"_p_SoFont", "SoFont *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFontNameElement = {"_p_SoFontNameElement", "SoFontNameElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFontSizeElement = {"_p_SoFontSizeElement", "SoFontSizeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFontStyle = {"_p_SoFontStyle", "SoFontStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFragmentShader = {"_p_SoFragmentShader", "SoFragmentShader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFrustumCamera = {"_p_SoFrustumCamera", "SoFrustumCamera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoFullPath = {"_p_SoFullPath", "SoFullPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLBigImage = {"_p_SoGLBigImage", "SoGLBigImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLCacheContextElement = {"_p_SoGLCacheContextElement", "SoGLCacheContextElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLCacheList = {"_p_SoGLCacheList", "SoGLCacheList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLClipPlaneElement = {"_p_SoGLClipPlaneElement", "SoGLClipPlaneElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLColorIndexElement = {"_p_SoGLColorIndexElement", "SoGLColorIndexElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLCoordinateElement = {"_p_SoGLCoordinateElement", "SoGLCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLDepthBufferElement = {"_p_SoGLDepthBufferElement", "SoGLDepthBufferElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLDisplayList = {"_p_SoGLDisplayList", "SoGLDisplayList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLDrawStyleElement = {"_p_SoGLDrawStyleElement", "SoGLDrawStyleElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLEnvironmentElement = {"_p_SoGLEnvironmentElement", "SoGLEnvironmentElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLImage = {"_p_SoGLImage", "SoGLImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLImageResizeCB = {"_p_SoGLImageResizeCB", "SoGLImageResizeCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLLazyElement = {"_p_SoGLLazyElement", "SoGLLazyElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLLazyElement__GLState = {"_p_SoGLLazyElement__GLState", "SoGLLazyElement::GLState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLLightIdElement = {"_p_SoGLLightIdElement", "SoGLLightIdElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLLinePatternElement = {"_p_SoGLLinePatternElement", "SoGLLinePatternElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLLineWidthElement = {"_p_SoGLLineWidthElement", "SoGLLineWidthElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLModelMatrixElement = {"_p_SoGLModelMatrixElement", "SoGLModelMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLMultiTextureCoordinateElement = {"_p_SoGLMultiTextureCoordinateElement", "SoGLTextureCoordinateElement *|SoGLMultiTextureCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLMultiTextureEnabledElement = {"_p_SoGLMultiTextureEnabledElement", "SoGLTextureEnabledElement *|SoGLMultiTextureEnabledElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLMultiTextureImageElement = {"_p_SoGLMultiTextureImageElement", "SoGLTextureImageElement *|SoGLMultiTextureImageElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLMultiTextureMatrixElement = {"_p_SoGLMultiTextureMatrixElement", "SoGLTextureMatrixElement *|SoGLMultiTextureMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLNormalElement = {"_p_SoGLNormalElement", "SoGLNormalElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLPointSizeElement = {"_p_SoGLPointSizeElement", "SoGLPointSizeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLPolygonOffsetElement = {"_p_SoGLPolygonOffsetElement", "SoGLPolygonOffsetElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLProjectionMatrixElement = {"_p_SoGLProjectionMatrixElement", "SoGLProjectionMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLRenderAbortCB = {"_p_SoGLRenderAbortCB", "SoGLRenderAbortCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLRenderAction = {"_p_SoGLRenderAction", "SoGLRenderAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLRenderCache = {"_p_SoGLRenderCache", "SoGLRenderCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLRenderPassElement = {"_p_SoGLRenderPassElement", "SoGLRenderPassElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLShaderObject = {"_p_SoGLShaderObject", "SoGLShaderObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLShapeHintsElement = {"_p_SoGLShapeHintsElement", "SoGLShapeHintsElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLUpdateAreaElement = {"_p_SoGLUpdateAreaElement", "SoGLUpdateAreaElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLVBOElement = {"_p_SoGLVBOElement", "SoGLVBOElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLVertexAttributeElement = {"_p_SoGLVertexAttributeElement", "SoGLVertexAttributeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLViewingMatrixElement = {"_p_SoGLViewingMatrixElement", "SoGLViewingMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGLViewportRegionElement = {"_p_SoGLViewportRegionElement", "SoGLViewportRegionElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGate = {"_p_SoGate", "SoGate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGeo = {"_p_SoGeo", "SoGeo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGeoCoordinate = {"_p_SoGeoCoordinate", "SoGeoCoordinate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGeoLocation = {"_p_SoGeoLocation", "SoGeoLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGeoOrigin = {"_p_SoGeoOrigin", "SoGeoOrigin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGeoSeparator = {"_p_SoGeoSeparator", "SoGeoSeparator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGetBoundingBoxAction = {"_p_SoGetBoundingBoxAction", "SoGetBoundingBoxAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGetMatrixAction = {"_p_SoGetMatrixAction", "SoGetMatrixAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGetPrimitiveCountAction = {"_p_SoGetPrimitiveCountAction", "SoGetPrimitiveCountAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGlyph = {"_p_SoGlyph", "SoGlyph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoGroup = {"_p_SoGroup", "SoGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoHandleBoxDragger = {"_p_SoHandleBoxDragger", "SoHandleBoxDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoHandleBoxManip = {"_p_SoHandleBoxManip", "SoHandleBoxManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoHandleEventAction = {"_p_SoHandleEventAction", "SoHandleEventAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoHardCopy = {"_p_SoHardCopy", "SoHardCopy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoHeightMapToNormalMap = {"_p_SoHeightMapToNormalMap", "SoHeightMapToNormalMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIdleSensor = {"_p_SoIdleSensor", "SoIdleSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoImage = {"_p_SoImage", "SoImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedFaceSet = {"_p_SoIndexedFaceSet", "SoIndexedFaceSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedLineSet = {"_p_SoIndexedLineSet", "SoIndexedLineSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedMarkerSet = {"_p_SoIndexedMarkerSet", "SoIndexedMarkerSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedNurbsCurve = {"_p_SoIndexedNurbsCurve", "SoIndexedNurbsCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedNurbsSurface = {"_p_SoIndexedNurbsSurface", "SoIndexedNurbsSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedPointSet = {"_p_SoIndexedPointSet", "SoIndexedPointSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedShape = {"_p_SoIndexedShape", "SoIndexedShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIndexedTriangleStripSet = {"_p_SoIndexedTriangleStripSet", "SoIndexedTriangleStripSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInfo = {"_p_SoInfo", "SoInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInput = {"_p_SoInput", "SoInput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInt32Element = {"_p_SoInt32Element", "SoInt32Element *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInteraction = {"_p_SoInteraction", "SoInteraction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInteractionKit = {"_p_SoInteractionKit", "SoInteractionKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolate = {"_p_SoInterpolate", "SoInterpolate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolateFloat = {"_p_SoInterpolateFloat", "SoInterpolateFloat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolateRotation = {"_p_SoInterpolateRotation", "SoInterpolateRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolateVec2f = {"_p_SoInterpolateVec2f", "SoInterpolateVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolateVec3f = {"_p_SoInterpolateVec3f", "SoInterpolateVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoInterpolateVec4f = {"_p_SoInterpolateVec4f", "SoInterpolateVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIntersectingPrimitive = {"_p_SoIntersectingPrimitive", "SoIntersectingPrimitive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIntersectionCB = {"_p_SoIntersectionCB", "SoIntersectionCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIntersectionDetectionAction = {"_p_SoIntersectionDetectionAction", "SoIntersectionDetectionAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIntersectionFilterCB = {"_p_SoIntersectionFilterCB", "SoIntersectionFilterCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoIntersectionVisitationCB = {"_p_SoIntersectionVisitationCB", "SoIntersectionVisitationCB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoJackDragger = {"_p_SoJackDragger", "SoJackDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoJackManip = {"_p_SoJackManip", "SoJackManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoKeyboardEvent = {"_p_SoKeyboardEvent", "SoKeyboardEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLOD = {"_p_SoLOD", "SoLOD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLabel = {"_p_SoLabel", "SoLabel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLazyElement = {"_p_SoLazyElement", "SoLazyElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLevelOfDetail = {"_p_SoLevelOfDetail", "SoLevelOfDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLight = {"_p_SoLight", "SoLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightAttenuationElement = {"_p_SoLightAttenuationElement", "SoLightAttenuationElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightElement = {"_p_SoLightElement", "SoLightElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightKit = {"_p_SoLightKit", "SoLightKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightModel = {"_p_SoLightModel", "SoLightModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightModelElement = {"_p_SoLightModelElement", "SoLightModelElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLightPath = {"_p_SoLightPath", "SoLightPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLineDetail = {"_p_SoLineDetail", "SoLineDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLineHighlightRenderAction = {"_p_SoLineHighlightRenderAction", "SoLineHighlightRenderAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLinePatternElement = {"_p_SoLinePatternElement", "SoLinePatternElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLineSet = {"_p_SoLineSet", "SoLineSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLineWidthElement = {"_p_SoLineWidthElement", "SoLineWidthElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLinearProfile = {"_p_SoLinearProfile", "SoLinearProfile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoListener = {"_p_SoListener", "SoListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoListenerDopplerElement = {"_p_SoListenerDopplerElement", "SoListenerDopplerElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoListenerGainElement = {"_p_SoListenerGainElement", "SoListenerGainElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoListenerOrientationElement = {"_p_SoListenerOrientationElement", "SoListenerOrientationElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoListenerPositionElement = {"_p_SoListenerPositionElement", "SoListenerPositionElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLocalBBoxMatrixElement = {"_p_SoLocalBBoxMatrixElement", "SoLocalBBoxMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLocateHighlight = {"_p_SoLocateHighlight", "SoLocateHighlight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLocation2Event = {"_p_SoLocation2Event", "SoLocation2Event *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoLockManager = {"_p_SoLockManager", "SoLockManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFBitMask = {"_p_SoMFBitMask", "SoMFBitMask *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFBool = {"_p_SoMFBool", "SoMFBool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFColor = {"_p_SoMFColor", "SoMFColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFColorRGBA = {"_p_SoMFColorRGBA", "SoMFColorRGBA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFDouble = {"_p_SoMFDouble", "SoMFDouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFEngine = {"_p_SoMFEngine", "SoMFEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFEnum = {"_p_SoMFEnum", "SoMFEnum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFFloat = {"_p_SoMFFloat", "SoMFFloat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFInt32 = {"_p_SoMFInt32", "SoMFInt32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFMatrix = {"_p_SoMFMatrix", "SoMFMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFName = {"_p_SoMFName", "SoMFName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFNode = {"_p_SoMFNode", "SoMFNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFPath = {"_p_SoMFPath", "SoMFPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFPlane = {"_p_SoMFPlane", "SoMFPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFRotation = {"_p_SoMFRotation", "SoMFRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFShort = {"_p_SoMFShort", "SoMFShort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFString = {"_p_SoMFString", "SoMFString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFTime = {"_p_SoMFTime", "SoMFTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFUInt32 = {"_p_SoMFUInt32", "SoMFUInt32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFUShort = {"_p_SoMFUShort", "SoMFUShort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec2b = {"_p_SoMFVec2b", "SoMFVec2b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec2d = {"_p_SoMFVec2d", "SoMFVec2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec2f = {"_p_SoMFVec2f", "SoMFVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec2i32 = {"_p_SoMFVec2i32", "SoMFVec2i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec2s = {"_p_SoMFVec2s", "SoMFVec2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec3b = {"_p_SoMFVec3b", "SoMFVec3b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec3d = {"_p_SoMFVec3d", "SoMFVec3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec3f = {"_p_SoMFVec3f", "SoMFVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec3i32 = {"_p_SoMFVec3i32", "SoMFVec3i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec3s = {"_p_SoMFVec3s", "SoMFVec3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4b = {"_p_SoMFVec4b", "SoMFVec4b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4d = {"_p_SoMFVec4d", "SoMFVec4d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4f = {"_p_SoMFVec4f", "SoMFVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4i32 = {"_p_SoMFVec4i32", "SoMFVec4i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4s = {"_p_SoMFVec4s", "SoMFVec4s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4ub = {"_p_SoMFVec4ub", "SoMFVec4ub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4ui32 = {"_p_SoMFVec4ui32", "SoMFVec4ui32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFVec4us = {"_p_SoMFVec4us", "SoMFVec4us *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMField = {"_p_SoMField", "SoMField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMarkerSet = {"_p_SoMarkerSet", "SoMarkerSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMaterial = {"_p_SoMaterial", "SoMaterial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMaterialBinding = {"_p_SoMaterialBinding", "SoMaterialBinding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMaterialBindingElement = {"_p_SoMaterialBindingElement", "SoMaterialBindingElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMaterialBundle = {"_p_SoMaterialBundle", "SoMaterialBundle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMatrixTransform = {"_p_SoMatrixTransform", "SoMatrixTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMemoryError = {"_p_SoMemoryError", "SoMemoryError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoModelMatrixElement = {"_p_SoModelMatrixElement", "SoModelMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMotion3Event = {"_p_SoMotion3Event", "SoMotion3Event *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMouseButtonEvent = {"_p_SoMouseButtonEvent", "SoMouseButtonEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureCoordinateElement = {"_p_SoMultiTextureCoordinateElement", "SoTextureCoordinateElement *|SoMultiTextureCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureEnabledElement = {"_p_SoMultiTextureEnabledElement", "SoTextureEnabledElement *|SoMultiTextureEnabledElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureEnabledElement__Mode = {"_p_SoMultiTextureEnabledElement__Mode", "SoMultiTextureEnabledElement::Mode *|enum SoMultiTextureEnabledElement::Mode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureImageElement = {"_p_SoMultiTextureImageElement", "SoTextureImageElement *|SoMultiTextureImageElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureImageElement__Model = {"_p_SoMultiTextureImageElement__Model", "SoMultiTextureImageElement::Model *|enum SoMultiTextureImageElement::Model *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureImageElement__Wrap = {"_p_SoMultiTextureImageElement__Wrap", "SoMultiTextureImageElement::Wrap *|enum SoMultiTextureImageElement::Wrap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultiTextureMatrixElement = {"_p_SoMultiTextureMatrixElement", "SoTextureMatrixElement *|SoMultiTextureMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMultipleCopy = {"_p_SoMultipleCopy", "SoMultipleCopy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNode = {"_p_SoNode", "SoNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeEngine = {"_p_SoNodeEngine", "SoNodeEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeKit = {"_p_SoNodeKit", "SoNodeKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeKitDetail = {"_p_SoNodeKitDetail", "SoNodeKitDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeKitListPart = {"_p_SoNodeKitListPart", "SoNodeKitListPart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeKitPath = {"_p_SoNodeKitPath", "SoNodeKitPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeList = {"_p_SoNodeList", "SoNodeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodeSensor = {"_p_SoNodeSensor", "SoNodeSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNodekitCatalog = {"_p_SoNodekitCatalog", "SoNodekitCatalog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNonIndexedShape = {"_p_SoNonIndexedShape", "SoNonIndexedShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormal = {"_p_SoNormal", "SoNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalBinding = {"_p_SoNormalBinding", "SoNormalBinding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalBindingElement = {"_p_SoNormalBindingElement", "SoNormalBindingElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalBundle = {"_p_SoNormalBundle", "SoNormalBundle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalCache = {"_p_SoNormalCache", "SoNormalCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalElement = {"_p_SoNormalElement", "SoNormalElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNormalGenerator = {"_p_SoNormalGenerator", "SoNormalGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNotList = {"_p_SoNotList", "SoNotList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNotRec = {"_p_SoNotRec", "SoNotRec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNurbsCurve = {"_p_SoNurbsCurve", "SoNurbsCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNurbsProfile = {"_p_SoNurbsProfile", "SoNurbsProfile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoNurbsSurface = {"_p_SoNurbsSurface", "SoNurbsSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOffscreenRenderer = {"_p_SoOffscreenRenderer", "SoOffscreenRenderer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOnOff = {"_p_SoOnOff", "SoOnOff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOneShot = {"_p_SoOneShot", "SoOneShot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOneShotSensor = {"_p_SoOneShotSensor", "SoOneShotSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOrthographicCamera = {"_p_SoOrthographicCamera", "SoOrthographicCamera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOutput = {"_p_SoOutput", "SoOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoOverrideElement = {"_p_SoOverrideElement", "SoOverrideElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPSVectorOutput = {"_p_SoPSVectorOutput", "SoPSVectorOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPackedColor = {"_p_SoPackedColor", "SoPackedColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPath = {"_p_SoPath", "SoPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPathList = {"_p_SoPathList", "SoPathList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPathSensor = {"_p_SoPathSensor", "SoPathSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPathSwitch = {"_p_SoPathSwitch", "SoPathSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPendulum = {"_p_SoPendulum", "SoPendulum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPerspectiveCamera = {"_p_SoPerspectiveCamera", "SoPerspectiveCamera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickAction = {"_p_SoPickAction", "SoPickAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickRayElement = {"_p_SoPickRayElement", "SoPickRayElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickStyle = {"_p_SoPickStyle", "SoPickStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickStyleElement = {"_p_SoPickStyleElement", "SoPickStyleElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickedPoint = {"_p_SoPickedPoint", "SoPickedPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPickedPointList = {"_p_SoPickedPointList", "SoPickedPointList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointDetail = {"_p_SoPointDetail", "SoPointDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointLight = {"_p_SoPointLight", "SoPointLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointLightDragger = {"_p_SoPointLightDragger", "SoPointLightDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointLightManip = {"_p_SoPointLightManip", "SoPointLightManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointSet = {"_p_SoPointSet", "SoPointSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPointSizeElement = {"_p_SoPointSizeElement", "SoPointSizeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPolygonOffset = {"_p_SoPolygonOffset", "SoPolygonOffset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPolygonOffsetElement = {"_p_SoPolygonOffsetElement", "SoPolygonOffsetElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPolygonOffsetElement__Style = {"_p_SoPolygonOffsetElement__Style", "SoPolygonOffsetElement::Style *|enum SoPolygonOffsetElement::Style *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoPrimitiveVertex = {"_p_SoPrimitiveVertex", "SoPrimitiveVertex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProfile = {"_p_SoProfile", "SoProfile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProfileCoordinate2 = {"_p_SoProfileCoordinate2", "SoProfileCoordinate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProfileCoordinate3 = {"_p_SoProfileCoordinate3", "SoProfileCoordinate3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProfileCoordinateElement = {"_p_SoProfileCoordinateElement", "SoProfileCoordinateElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProfileElement = {"_p_SoProfileElement", "SoProfileElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProjectionMatrixElement = {"_p_SoProjectionMatrixElement", "SoProjectionMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProto = {"_p_SoProto", "SoProto *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoProtoInstance = {"_p_SoProtoInstance", "SoProtoInstance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQuadMesh = {"_p_SoQuadMesh", "SoQuadMesh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRayPickAction = {"_p_SoRayPickAction", "SoRayPickAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoReadError = {"_p_SoReadError", "SoReadError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRenderManager = {"_p_SoRenderManager", "SoRenderManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRenderManager__Superimposition = {"_p_SoRenderManager__Superimposition", "SoRenderManager::Superimposition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoReorganizeAction = {"_p_SoReorganizeAction", "SoReorganizeAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoReplacedElement = {"_p_SoReplacedElement", "SoReplacedElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoResetTransform = {"_p_SoResetTransform", "SoResetTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoReversePerspectiveCamera = {"_p_SoReversePerspectiveCamera", "SoReversePerspectiveCamera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotateCylindricalDragger = {"_p_SoRotateCylindricalDragger", "SoRotateCylindricalDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotateDiscDragger = {"_p_SoRotateDiscDragger", "SoRotateDiscDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotateSphericalDragger = {"_p_SoRotateSphericalDragger", "SoRotateSphericalDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotation = {"_p_SoRotation", "SoRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotationXYZ = {"_p_SoRotationXYZ", "SoRotationXYZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoRotor = {"_p_SoRotor", "SoRotor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBitMask = {"_p_SoSFBitMask", "SoSFBitMask *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBool = {"_p_SoSFBool", "SoSFBool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox2d = {"_p_SoSFBox2d", "SoSFBox2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox2f = {"_p_SoSFBox2f", "SoSFBox2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox2i32 = {"_p_SoSFBox2i32", "SoSFBox2i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox2s = {"_p_SoSFBox2s", "SoSFBox2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox3d = {"_p_SoSFBox3d", "SoSFBox3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox3f = {"_p_SoSFBox3f", "SoSFBox3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox3i32 = {"_p_SoSFBox3i32", "SoSFBox3i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFBox3s = {"_p_SoSFBox3s", "SoSFBox3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFColor = {"_p_SoSFColor", "SoSFColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFColorRGBA = {"_p_SoSFColorRGBA", "SoSFColorRGBA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFDouble = {"_p_SoSFDouble", "SoSFDouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFEngine = {"_p_SoSFEngine", "SoSFEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFEnum = {"_p_SoSFEnum", "SoSFEnum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFFloat = {"_p_SoSFFloat", "SoSFFloat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFImage = {"_p_SoSFImage", "SoSFImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFImage3 = {"_p_SoSFImage3", "SoSFImage3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFInt32 = {"_p_SoSFInt32", "SoSFInt32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFMatrix = {"_p_SoSFMatrix", "SoSFMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFName = {"_p_SoSFName", "SoSFName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFNode = {"_p_SoSFNode", "SoSFNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFPath = {"_p_SoSFPath", "SoSFPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFPlane = {"_p_SoSFPlane", "SoSFPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFRotation = {"_p_SoSFRotation", "SoSFRotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFShort = {"_p_SoSFShort", "SoSFShort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFString = {"_p_SoSFString", "SoSFString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFTime = {"_p_SoSFTime", "SoSFTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFTrigger = {"_p_SoSFTrigger", "SoSFTrigger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFUInt32 = {"_p_SoSFUInt32", "SoSFUInt32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFUShort = {"_p_SoSFUShort", "SoSFUShort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec2b = {"_p_SoSFVec2b", "SoSFVec2b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec2d = {"_p_SoSFVec2d", "SoSFVec2d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec2f = {"_p_SoSFVec2f", "SoSFVec2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec2i32 = {"_p_SoSFVec2i32", "SoSFVec2i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec2s = {"_p_SoSFVec2s", "SoSFVec2s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec3b = {"_p_SoSFVec3b", "SoSFVec3b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec3d = {"_p_SoSFVec3d", "SoSFVec3d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec3f = {"_p_SoSFVec3f", "SoSFVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec3i32 = {"_p_SoSFVec3i32", "SoSFVec3i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec3s = {"_p_SoSFVec3s", "SoSFVec3s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4b = {"_p_SoSFVec4b", "SoSFVec4b *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4d = {"_p_SoSFVec4d", "SoSFVec4d *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4f = {"_p_SoSFVec4f", "SoSFVec4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4i32 = {"_p_SoSFVec4i32", "SoSFVec4i32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4s = {"_p_SoSFVec4s", "SoSFVec4s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4ub = {"_p_SoSFVec4ub", "SoSFVec4ub *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4ui32 = {"_p_SoSFVec4ui32", "SoSFVec4ui32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSFVec4us = {"_p_SoSFVec4us", "SoSFVec4us *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSField = {"_p_SoSField", "SoSField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLDollyTarget = {"_p_SoScXMLDollyTarget", "SoScXMLDollyTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLEvent = {"_p_SoScXMLEvent", "SoScXMLEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLFlightControlTarget = {"_p_SoScXMLFlightControlTarget", "SoScXMLFlightControlTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLMiscTarget = {"_p_SoScXMLMiscTarget", "SoScXMLMiscTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLMotionTarget = {"_p_SoScXMLMotionTarget", "SoScXMLMotionTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLNavigation = {"_p_SoScXMLNavigation", "SoScXMLNavigation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLNavigationTarget = {"_p_SoScXMLNavigationTarget", "SoScXMLNavigationTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLPanTarget = {"_p_SoScXMLPanTarget", "SoScXMLPanTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLRotateTarget = {"_p_SoScXMLRotateTarget", "SoScXMLRotateTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLSeekTarget = {"_p_SoScXMLSeekTarget", "SoScXMLSeekTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLSpinTarget = {"_p_SoScXMLSpinTarget", "SoScXMLSpinTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLStateMachine = {"_p_SoScXMLStateMachine", "SoScXMLStateMachine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScXMLZoomTarget = {"_p_SoScXMLZoomTarget", "SoScXMLZoomTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScale = {"_p_SoScale", "SoScale *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScale1Dragger = {"_p_SoScale1Dragger", "SoScale1Dragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScale2Dragger = {"_p_SoScale2Dragger", "SoScale2Dragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScale2UniformDragger = {"_p_SoScale2UniformDragger", "SoScale2UniformDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoScaleUniformDragger = {"_p_SoScaleUniformDragger", "SoScaleUniformDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSceneKit = {"_p_SoSceneKit", "SoSceneKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSceneManager = {"_p_SoSceneManager", "SoSceneManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSceneTexture2 = {"_p_SoSceneTexture2", "SoSceneTexture2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSceneTextureCubeMap = {"_p_SoSceneTextureCubeMap", "SoSceneTextureCubeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSearchAction = {"_p_SoSearchAction", "SoSearchAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSelectOne = {"_p_SoSelectOne", "SoSelectOne *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSelection = {"_p_SoSelection", "SoSelection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSensor = {"_p_SoSensor", "SoSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSensorManager = {"_p_SoSensorManager", "SoSensorManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSeparator = {"_p_SoSeparator", "SoSeparator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSeparatorKit = {"_p_SoSeparatorKit", "SoSeparatorKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderObject = {"_p_SoShaderObject", "SoShaderObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter = {"_p_SoShaderParameter", "SoShaderParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter1f = {"_p_SoShaderParameter1f", "SoShaderParameter1f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter1i = {"_p_SoShaderParameter1i", "SoShaderParameter1i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter2f = {"_p_SoShaderParameter2f", "SoShaderParameter2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter2i = {"_p_SoShaderParameter2i", "SoShaderParameter2i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter3f = {"_p_SoShaderParameter3f", "SoShaderParameter3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter3i = {"_p_SoShaderParameter3i", "SoShaderParameter3i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter4f = {"_p_SoShaderParameter4f", "SoShaderParameter4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameter4i = {"_p_SoShaderParameter4i", "SoShaderParameter4i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray1f = {"_p_SoShaderParameterArray1f", "SoShaderParameterArray1f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray1i = {"_p_SoShaderParameterArray1i", "SoShaderParameterArray1i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray2f = {"_p_SoShaderParameterArray2f", "SoShaderParameterArray2f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray2i = {"_p_SoShaderParameterArray2i", "SoShaderParameterArray2i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray3f = {"_p_SoShaderParameterArray3f", "SoShaderParameterArray3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray3i = {"_p_SoShaderParameterArray3i", "SoShaderParameterArray3i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray4f = {"_p_SoShaderParameterArray4f", "SoShaderParameterArray4f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray4i = {"_p_SoShaderParameterArray4i", "SoShaderParameterArray4i *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterMatrix = {"_p_SoShaderParameterMatrix", "SoShaderParameterMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderParameterMatrixArray = {"_p_SoShaderParameterMatrixArray", "SoShaderParameterMatrixArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderProgram = {"_p_SoShaderProgram", "SoShaderProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShaderStateMatrixParameter = {"_p_SoShaderStateMatrixParameter", "SoShaderStateMatrixParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShape = {"_p_SoShape", "SoShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeHints = {"_p_SoShapeHints", "SoShapeHints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeHintsElement = {"_p_SoShapeHintsElement", "SoShapeHintsElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeHintsElement__FaceType = {"_p_SoShapeHintsElement__FaceType", "SoShapeHintsElement::FaceType *|enum SoShapeHintsElement::FaceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeHintsElement__ShapeType = {"_p_SoShapeHintsElement__ShapeType", "SoShapeHintsElement::ShapeType *|enum SoShapeHintsElement::ShapeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeHintsElement__VertexOrdering = {"_p_SoShapeHintsElement__VertexOrdering", "SoShapeHintsElement::VertexOrdering *|enum SoShapeHintsElement::VertexOrdering *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeKit = {"_p_SoShapeKit", "SoShapeKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShapeStyleElement = {"_p_SoShapeStyleElement", "SoShapeStyleElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShininessElement = {"_p_SoShininessElement", "SoShininessElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoShuttle = {"_p_SoShuttle", "SoShuttle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSimplifier = {"_p_SoSimplifier", "SoSimplifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSimplifyAction = {"_p_SoSimplifyAction", "SoSimplifyAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSoundElement = {"_p_SoSoundElement", "SoSoundElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSpaceballButtonEvent = {"_p_SoSpaceballButtonEvent", "SoSpaceballButtonEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSpecularColorElement = {"_p_SoSpecularColorElement", "SoSpecularColorElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSphere = {"_p_SoSphere", "SoSphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSpotLight = {"_p_SoSpotLight", "SoSpotLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSpotLightDragger = {"_p_SoSpotLightDragger", "SoSpotLightDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSpotLightManip = {"_p_SoSpotLightManip", "SoSpotLightManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoState = {"_p_SoState", "SoState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSurroundScale = {"_p_SoSurroundScale", "SoSurroundScale *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSwitch = {"_p_SoSwitch", "SoSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoSwitchElement = {"_p_SoSwitchElement", "SoSwitchElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTabBoxDragger = {"_p_SoTabBoxDragger", "SoTabBoxDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTabBoxManip = {"_p_SoTabBoxManip", "SoTabBoxManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTabPlaneDragger = {"_p_SoTabPlaneDragger", "SoTabPlaneDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTempPath = {"_p_SoTempPath", "SoTempPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoText2 = {"_p_SoText2", "SoText2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoText3 = {"_p_SoText3", "SoText3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextDetail = {"_p_SoTextDetail", "SoTextDetail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextOutlineEnabledElement = {"_p_SoTextOutlineEnabledElement", "SoTextOutlineEnabledElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture = {"_p_SoTexture", "SoTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture2 = {"_p_SoTexture2", "SoTexture2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture2Convert = {"_p_SoTexture2Convert", "SoTexture2Convert *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture2Transform = {"_p_SoTexture2Transform", "SoTexture2Transform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture3 = {"_p_SoTexture3", "SoTexture3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTexture3Transform = {"_p_SoTexture3Transform", "SoTexture3Transform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCombine = {"_p_SoTextureCombine", "SoTextureCombine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCombineElement = {"_p_SoTextureCombineElement", "SoTextureCombineElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCombineElement__Operand = {"_p_SoTextureCombineElement__Operand", "SoTextureCombineElement::Operand *|enum SoTextureCombineElement::Operand *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCombineElement__Operation = {"_p_SoTextureCombineElement__Operation", "SoTextureCombineElement::Operation *|enum SoTextureCombineElement::Operation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCombineElement__Source = {"_p_SoTextureCombineElement__Source", "SoTextureCombineElement::Source *|enum SoTextureCombineElement::Source *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinate2 = {"_p_SoTextureCoordinate2", "SoTextureCoordinate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinate3 = {"_p_SoTextureCoordinate3", "SoTextureCoordinate3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateBinding = {"_p_SoTextureCoordinateBinding", "SoTextureCoordinateBinding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateBindingElement = {"_p_SoTextureCoordinateBindingElement", "SoTextureCoordinateBindingElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateBundle = {"_p_SoTextureCoordinateBundle", "SoTextureCoordinateBundle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateCache = {"_p_SoTextureCoordinateCache", "SoTextureCoordinateCache *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateCube = {"_p_SoTextureCoordinateCube", "SoTextureCoordinateCube *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateCylinder = {"_p_SoTextureCoordinateCylinder", "SoTextureCoordinateCylinder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateDefault = {"_p_SoTextureCoordinateDefault", "SoTextureCoordinateDefault *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateEnvironment = {"_p_SoTextureCoordinateEnvironment", "SoTextureCoordinateEnvironment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateFunction = {"_p_SoTextureCoordinateFunction", "SoTextureCoordinateFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateNormalMap = {"_p_SoTextureCoordinateNormalMap", "SoTextureCoordinateNormalMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateObject = {"_p_SoTextureCoordinateObject", "SoTextureCoordinateObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinatePlane = {"_p_SoTextureCoordinatePlane", "SoTextureCoordinatePlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateReflectionMap = {"_p_SoTextureCoordinateReflectionMap", "SoTextureCoordinateReflectionMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateSphere = {"_p_SoTextureCoordinateSphere", "SoTextureCoordinateSphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureCubeMap = {"_p_SoTextureCubeMap", "SoTextureCubeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureMatrixTransform = {"_p_SoTextureMatrixTransform", "SoTextureMatrixTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureOverrideElement = {"_p_SoTextureOverrideElement", "SoTextureOverrideElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureQualityElement = {"_p_SoTextureQualityElement", "SoTextureQualityElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureScalePolicy = {"_p_SoTextureScalePolicy", "SoTextureScalePolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureUnit = {"_p_SoTextureUnit", "SoTextureUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTextureUnitElement = {"_p_SoTextureUnitElement", "SoTextureUnitElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTimeCounter = {"_p_SoTimeCounter", "SoTimeCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTimerQueueSensor = {"_p_SoTimerQueueSensor", "SoTimerQueueSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTimerSensor = {"_p_SoTimerSensor", "SoTimerSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoToVRML2Action = {"_p_SoToVRML2Action", "SoToVRML2Action *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoToVRMLAction = {"_p_SoToVRMLAction", "SoToVRMLAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTrackballDragger = {"_p_SoTrackballDragger", "SoTrackballDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTrackballManip = {"_p_SoTrackballManip", "SoTrackballManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTranReceiver = {"_p_SoTranReceiver", "SoTranReceiver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTranSender = {"_p_SoTranSender", "SoTranSender *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransform = {"_p_SoTransform", "SoTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformBoxDragger = {"_p_SoTransformBoxDragger", "SoTransformBoxDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformBoxManip = {"_p_SoTransformBoxManip", "SoTransformBoxManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformManip = {"_p_SoTransformManip", "SoTransformManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformSeparator = {"_p_SoTransformSeparator", "SoTransformSeparator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformVec3f = {"_p_SoTransformVec3f", "SoTransformVec3f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformation = {"_p_SoTransformation", "SoTransformation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformerDragger = {"_p_SoTransformerDragger", "SoTransformerDragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransformerManip = {"_p_SoTransformerManip", "SoTransformerManip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTranslate1Dragger = {"_p_SoTranslate1Dragger", "SoTranslate1Dragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTranslate2Dragger = {"_p_SoTranslate2Dragger", "SoTranslate2Dragger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTranslation = {"_p_SoTranslation", "SoTranslation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransparencyElement = {"_p_SoTransparencyElement", "SoTransparencyElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTransparencyType = {"_p_SoTransparencyType", "SoTransparencyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTriangleStripSet = {"_p_SoTriangleStripSet", "SoTriangleStripSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTriggerAny = {"_p_SoTriggerAny", "SoTriggerAny *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoType = {"_p_SoType", "SoType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoTypeList = {"_p_SoTypeList", "SoTypeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoUniformShaderParameter = {"_p_SoUniformShaderParameter", "SoUniformShaderParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoUnits = {"_p_SoUnits", "SoUnits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoUnitsElement = {"_p_SoUnitsElement", "SoUnitsElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVBO = {"_p_SoVBO", "SoVBO *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLAnchor = {"_p_SoVRMLAnchor", "SoVRMLAnchor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLAppearance = {"_p_SoVRMLAppearance", "SoVRMLAppearance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLAudioClip = {"_p_SoVRMLAudioClip", "SoVRMLAudioClip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLBackground = {"_p_SoVRMLBackground", "SoVRMLBackground *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLBillboard = {"_p_SoVRMLBillboard", "SoVRMLBillboard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLBox = {"_p_SoVRMLBox", "SoVRMLBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCollision = {"_p_SoVRMLCollision", "SoVRMLCollision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLColor = {"_p_SoVRMLColor", "SoVRMLColor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLColorInterpolator = {"_p_SoVRMLColorInterpolator", "SoVRMLColorInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCone = {"_p_SoVRMLCone", "SoVRMLCone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCoordinate = {"_p_SoVRMLCoordinate", "SoVRMLCoordinate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCoordinateInterpolator = {"_p_SoVRMLCoordinateInterpolator", "SoVRMLCoordinateInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCylinder = {"_p_SoVRMLCylinder", "SoVRMLCylinder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLCylinderSensor = {"_p_SoVRMLCylinderSensor", "SoVRMLCylinderSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLDirectionalLight = {"_p_SoVRMLDirectionalLight", "SoVRMLDirectionalLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLDragSensor = {"_p_SoVRMLDragSensor", "SoVRMLDragSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLElevationGrid = {"_p_SoVRMLElevationGrid", "SoVRMLElevationGrid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLExtrusion = {"_p_SoVRMLExtrusion", "SoVRMLExtrusion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLFog = {"_p_SoVRMLFog", "SoVRMLFog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLFontStyle = {"_p_SoVRMLFontStyle", "SoVRMLFontStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLGeometry = {"_p_SoVRMLGeometry", "SoVRMLGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLGroup = {"_p_SoVRMLGroup", "SoVRMLGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLImageTexture = {"_p_SoVRMLImageTexture", "SoVRMLImageTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedFaceSet = {"_p_SoVRMLIndexedFaceSet", "SoVRMLIndexedFaceSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedLine = {"_p_SoVRMLIndexedLine", "SoVRMLIndexedLine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedLineSet = {"_p_SoVRMLIndexedLineSet", "SoVRMLIndexedLineSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedShape = {"_p_SoVRMLIndexedShape", "SoVRMLIndexedShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLInline = {"_p_SoVRMLInline", "SoVRMLInline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLInterpolator = {"_p_SoVRMLInterpolator", "SoVRMLInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLLOD = {"_p_SoVRMLLOD", "SoVRMLLOD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLLight = {"_p_SoVRMLLight", "SoVRMLLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLMaterial = {"_p_SoVRMLMaterial", "SoVRMLMaterial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLMovieTexture = {"_p_SoVRMLMovieTexture", "SoVRMLMovieTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLNavigationInfo = {"_p_SoVRMLNavigationInfo", "SoVRMLNavigationInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLNormal = {"_p_SoVRMLNormal", "SoVRMLNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLNormalInterpolator = {"_p_SoVRMLNormalInterpolator", "SoVRMLNormalInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLOrientationInterpolator = {"_p_SoVRMLOrientationInterpolator", "SoVRMLOrientationInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLParent = {"_p_SoVRMLParent", "SoVRMLParent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLPixelTexture = {"_p_SoVRMLPixelTexture", "SoVRMLPixelTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLPlaneSensor = {"_p_SoVRMLPlaneSensor", "SoVRMLPlaneSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLPointLight = {"_p_SoVRMLPointLight", "SoVRMLPointLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLPointSet = {"_p_SoVRMLPointSet", "SoVRMLPointSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLPositionInterpolator = {"_p_SoVRMLPositionInterpolator", "SoVRMLPositionInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLProximitySensor = {"_p_SoVRMLProximitySensor", "SoVRMLProximitySensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLScalarInterpolator = {"_p_SoVRMLScalarInterpolator", "SoVRMLScalarInterpolator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLScript = {"_p_SoVRMLScript", "SoVRMLScript *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSensor = {"_p_SoVRMLSensor", "SoVRMLSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLShape = {"_p_SoVRMLShape", "SoVRMLShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSound = {"_p_SoVRMLSound", "SoVRMLSound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSphere = {"_p_SoVRMLSphere", "SoVRMLSphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSphereSensor = {"_p_SoVRMLSphereSensor", "SoVRMLSphereSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSpotLight = {"_p_SoVRMLSpotLight", "SoVRMLSpotLight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLSwitch = {"_p_SoVRMLSwitch", "SoVRMLSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLText = {"_p_SoVRMLText", "SoVRMLText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTexture = {"_p_SoVRMLTexture", "SoVRMLTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTextureCoordinate = {"_p_SoVRMLTextureCoordinate", "SoVRMLTextureCoordinate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTextureTransform = {"_p_SoVRMLTextureTransform", "SoVRMLTextureTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTimeSensor = {"_p_SoVRMLTimeSensor", "SoVRMLTimeSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTouchSensor = {"_p_SoVRMLTouchSensor", "SoVRMLTouchSensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLTransform = {"_p_SoVRMLTransform", "SoVRMLTransform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLVertexLine = {"_p_SoVRMLVertexLine", "SoVRMLVertexLine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLVertexPoint = {"_p_SoVRMLVertexPoint", "SoVRMLVertexPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLVertexShape = {"_p_SoVRMLVertexShape", "SoVRMLVertexShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLViewpoint = {"_p_SoVRMLViewpoint", "SoVRMLViewpoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLVisibilitySensor = {"_p_SoVRMLVisibilitySensor", "SoVRMLVisibilitySensor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVRMLWorldInfo = {"_p_SoVRMLWorldInfo", "SoVRMLWorldInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVectorOutput = {"_p_SoVectorOutput", "SoVectorOutput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVectorizeAction = {"_p_SoVectorizeAction", "SoVectorizeAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVectorizePSAction = {"_p_SoVectorizePSAction", "SoVectorizePSAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexAttribute = {"_p_SoVertexAttribute", "SoVertexAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexAttributeBinding = {"_p_SoVertexAttributeBinding", "SoVertexAttributeBinding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexAttributeBindingElement = {"_p_SoVertexAttributeBindingElement", "SoVertexAttributeBindingElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexAttributeData = {"_p_SoVertexAttributeData", "SoVertexAttributeData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexAttributeElement = {"_p_SoVertexAttributeElement", "SoVertexAttributeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexProperty = {"_p_SoVertexProperty", "SoVertexProperty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexShader = {"_p_SoVertexShader", "SoVertexShader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoVertexShape = {"_p_SoVertexShape", "SoVertexShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoViewVolumeElement = {"_p_SoViewVolumeElement", "SoViewVolumeElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoViewingMatrixElement = {"_p_SoViewingMatrixElement", "SoViewingMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoViewportRegionElement = {"_p_SoViewportRegionElement", "SoViewportRegionElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoWWWAnchor = {"_p_SoWWWAnchor", "SoWWWAnchor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoWWWInline = {"_p_SoWWWInline", "SoWWWInline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoWindowElement = {"_p_SoWindowElement", "SoWindowElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoWrapperKit = {"_p_SoWrapperKit", "SoWrapperKit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoWriteAction = {"_p_SoWriteAction", "SoWriteAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__double = {"_p_a_2__double", "double (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__doublep = {"_p_a_2__doublep", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_2__int = {"_p_a_2__int", "int32_t (*)[2]|int (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__intp = {"_p_a_2__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_2__short = {"_p_a_2__short", "short (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__signed_char = {"_p_a_2__signed_char", "int8_t (*)[2]|signed char (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__int = {"_p_a_3__int", "int32_t (*)[3]|int (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__intp = {"_p_a_3__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_3__short = {"_p_a_3__short", "short (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__signed_char = {"_p_a_3__signed_char", "int8_t (*)[3]|signed char (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__a_4__double = {"_p_a_4__a_4__double", "SbDPMat *|double (*)[4][4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__a_4__doublep = {"_p_a_4__a_4__doublep", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_4__a_4__float = {"_p_a_4__a_4__float", "SbMat *|float (*)[4][4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__a_4__floatp = {"_p_a_4__a_4__floatp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_4__double = {"_p_a_4__double", "double (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__doublep = {"_p_a_4__doublep", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_4__float = {"_p_a_4__float", "float (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__floatp = {"_p_a_4__floatp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_4__int = {"_p_a_4__int", "int32_t (*)[4]|int (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__intp = {"_p_a_4__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_4__short = {"_p_a_4__short", "short (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__signed_char = {"_p_a_4__signed_char", "int8_t (*)[4]|signed char (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__unsigned_char = {"_p_a_4__unsigned_char", "uint8_t (*)[4]|unsigned char (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__unsigned_int = {"_p_a_4__unsigned_int", "uint32_t (*)[4]|unsigned int (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__unsigned_short = {"_p_a_4__unsigned_short", "unsigned short (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cc_glglue = {"_p_cc_glglue", "cc_glue *|cc_glglue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cc_storage_f = {"_p_cc_storage_f", "cc_storage_f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cc_xml_doc = {"_p_cc_xml_doc", "cc_xml_doc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_cc_xml_elt = {"_p_cc_xml_elt", "cc_xml_elt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_charp = {"_p_charp", "charp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_close_func = {"_p_close_func", "close_func *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_char__char = {"_p_f_char__char", "char (*)(char)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_char__charp = {"_p_f_char__charp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_float_p_void__int = {"_p_f_float_p_void__int", "SbBool (*)(float,void *)|int (*)(float,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_float_p_void__intp = {"_p_f_float_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_SoAction_p_SoNode__void = {"_p_f_p_SoAction_p_SoNode__void", "SoActionMethod|void (*)(SoAction *,SoNode *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto = {"_p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto", "SoFetchExternProtoCB *|SoProto *(*)(SoInput *,SbString const *,int const,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int = {"_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int", "SoGLImage::SoGLImageResizeCB *|int (*)(SoState *,SbVec3s const &,unsigned char *,enum SoGLImage::ResizeReason,void *,SoGLImage *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp = {"_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__SoError_p_void__void = {"_p_f_p_q_const__SoError_p_void__void", "SoErrorCB *|void (*)(SoError const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__SoGLRenderAction__AbortCode = {"_p_f_p_void__SoGLRenderAction__AbortCode", "SoGLRenderAction::SoGLRenderAbortCB *|enum SoGLRenderAction::AbortCode (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__float = {"_p_f_p_void__float", "float (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__floatp = {"_p_f_p_void__floatp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void__int = {"_p_f_p_void__int", "int (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__intp = {"_p_f_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void__p_void = {"_p_f_p_void__p_void", "void *(*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "SoGLRenderPassCB *|SoTexCoordTexgenCB *|void (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_int__void = {"_p_f_p_void_int__void", "void (*)(void *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int = {"_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int", "SoVRMLAudioClip::seek_func *|int (*)(void *,long,int,SoVRMLAudioClip *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp = {"_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_ScXMLStateMachine__void = {"_p_f_p_void_p_ScXMLStateMachine__void", "ScXMLStateMachineDeleteCB *|void (*)(void *,ScXMLStateMachine *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void = {"_p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void", "ScXMLParallelStateChangeCB *|void (*)(void *,ScXMLStateMachine *,int,char const **,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void = {"_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void", "ScXMLStateChangeCB *|void (*)(void *,ScXMLStateMachine *,char const *,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoAction__void = {"_p_f_p_void_p_SoAction__void", "SoCallbackCB *|void (*)(void *,SoAction *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response", "SoCallbackAction::SoCallbackActionCB *|enum SoCallbackAction::Response (*)(void *,SoCallbackAction *,SoNode const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int", "SoExtSelectionPointCB *|int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void", "SoPointCB *|void (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int", "SoExtSelectionLineSegmentCB *|int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void", "SoLineSegmentCB *|void (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int", "SoExtSelectionTriangleCB *|int (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void = {"_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void", "SoTriangleCB *|void (*)(void *,SoCallbackAction *,SoPrimitiveVertex const *,SoPrimitiveVertex const *,SoPrimitiveVertex const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoDragger__void = {"_p_f_p_void_p_SoDragger__void", "SoDraggerCB *|void (*)(void *,SoDragger *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoEventCallback__void = {"_p_f_p_void_p_SoEventCallback__void", "SoEventCallbackCB *|void (*)(void *,SoEventCallback *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoGLRenderAction__float = {"_p_f_p_void_p_SoGLRenderAction__float", "SoGLSortedObjectOrderCB *|float (*)(void *,SoGLRenderAction *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoGLRenderAction__floatp = {"_p_f_p_void_p_SoGLRenderAction__floatp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoGLRenderAction__void = {"_p_f_p_void_p_SoGLRenderAction__void", "SoGLPreRenderCB *|void (*)(void *,SoGLRenderAction *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoInput__void = {"_p_f_p_void_p_SoInput__void", "SoDBHeaderCB *|void (*)(void *,SoInput *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoPath__void = {"_p_f_p_void_p_SoPath__void", "SoSelectionPathCB *|void (*)(void *,SoPath *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoRenderManager__void = {"_p_f_p_void_p_SoRenderManager__void", "SoRenderManagerRenderCB *|void (*)(void *,SoRenderManager *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoSceneManager__void = {"_p_f_p_void_p_SoSceneManager__void", "SoSceneManagerRenderCB *|void (*)(void *,SoSceneManager *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoSelection__void = {"_p_f_p_void_p_SoSelection__void", "SoSelectionClassCB *|void (*)(void *,SoSelection *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoSensor__void = {"_p_f_p_void_p_SoSensor__void", "SoSensorCB *|SoSensorCBPtr|void (*)(void *,SoSensor *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoState_q_const__int__void = {"_p_f_p_void_p_SoState_q_const__int__void", "SoShaderProgramEnableCB *|void (*)(void *,SoState *,int const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__int = {"_p_f_p_void_p_SoVRMLAudioClip_p_void__int", "SoVRMLAudioClip::close_func *|int (*)(void *,SoVRMLAudioClip *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__intp = {"_p_f_p_void_p_SoVRMLAudioClip_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__long = {"_p_f_p_void_p_SoVRMLAudioClip_p_void__long", "SoVRMLAudioClip::tell_func *|long (*)(void *,SoVRMLAudioClip *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__longp = {"_p_f_p_void_p_SoVRMLAudioClip_p_void__longp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoVRMLScript__void = {"_p_f_p_void_p_SoVRMLScript__void", "SoVRMLScriptEvaluateCB *|void (*)(void *,SoVRMLScript *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp = {"_p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp", "SoIntersectionDetectionAction::SoIntersectionCB *|enum SoIntersectionDetectionAction::Resp (*)(void *,SoIntersectingPrimitive const *,SoIntersectingPrimitive const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response = {"_p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response", "SoIntersectionDetectionAction::SoIntersectionVisitationCB *|enum SoCallbackAction::Response (*)(void *,SoPath const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath__p_SoPath = {"_p_f_p_void_p_q_const__SoPath__p_SoPath", "SoLassoSelectionFilterCB *|SoPath *(*)(void *,SoPath const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath__p_SoFullPath = {"_p_f_p_void_p_q_const__SoPath__p_SoFullPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath = {"_p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath__p_SoTempPath = {"_p_f_p_void_p_q_const__SoPath__p_SoTempPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int = {"_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int", "SoIntersectionDetectionAction::SoIntersectionFilterCB *|int (*)(void *,SoPath const *,SoPath const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp = {"_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoPath = {"_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath", "SoSelectionPickCB *|SoPath *(*)(void *,SoPickedPoint const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath = {"_p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath = {"_p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath = {"_p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_void__int = {"_p_f_p_void_p_void__int", "SbBool (*)(void *,void *)|int (*)(void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void__intp = {"_p_f_p_void_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_p_void__void = {"_p_f_p_void_p_void__void", "SbStorageApplyFunc *|SoCallbackListCB *|void (*)(void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t = {"_p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t", "SoVRMLAudioClip::read_func *|size_t (*)(void *,void *,int,int &,SoVRMLAudioClip *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void_p_void_p_void__void = {"_p_f_p_void_p_void_p_void_p_void__void", "SbTesselatorCB *|void (*)(void *,void *,void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f = {"_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f", "SoTextureCoordinateFunctionCB *|SbVec4f &(*)(void *,SbVec3f const &,SbVec3f const &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f = {"_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_size_t__p_void = {"_p_f_p_void_size_t__p_void", "SoOutputReallocCB *|void *(*)(void *,size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_unsigned_int__void = {"_p_f_p_void_unsigned_int__void", "SoScheduleDeleteCB *|void (*)(void *,unsigned int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int = {"_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int", "SbBool (*)(void *const,SbPlane const *const,int const)|int (*)(void *const,SbPlane const *const,int const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp = {"_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbBox3f__int = {"_p_f_q_const__p_void_r_q_const__SbBox3f__int", "SbBool (*)(void *const,SbBox3f const &)|int (*)(void *const,SbBox3f const &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbBox3f__intp = {"_p_f_q_const__p_void_r_q_const__SbBox3f__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbSphere__int = {"_p_f_q_const__p_void_r_q_const__SbSphere__int", "SbBool (*)(void *const,SbSphere const &)|int (*)(void *const,SbSphere const &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbSphere__intp = {"_p_f_q_const__p_void_r_q_const__SbSphere__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbVec3f__int = {"_p_f_q_const__p_void_r_q_const__SbVec3f__int", "SbBool (*)(void *const,SbVec3f const &)|int (*)(void *const,SbVec3f const &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_q_const__p_void_r_q_const__SbVec3f__intp = {"_p_f_q_const__p_void_r_q_const__SbVec3f__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_q_const__unsigned_int__unsigned_int = {"_p_f_q_const__unsigned_int__unsigned_int", "SbDictHashingFunc *|unsigned int (*)(unsigned int const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbName_float_int_p_void__int = {"_p_f_r_q_const__SbName_float_int_p_void__int", "SoDB::ProgressCallbackType *|int (*)(SbName const &,float,int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbName_float_int_p_void__intp = {"_p_f_r_q_const__SbName_float_int_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void = {"_p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void", "SoVRMLAudioClip::open_func *|void *(*)(SbStringList const &,SoVRMLAudioClip *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_SbImage_p_void__int = {"_p_f_r_q_const__SbString_p_SbImage_p_void__int", "SbImageReadImageCB *|SbImageScheduleReadCB *|int (*)(SbString const &,SbImage *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_SbImage_p_void__intp = {"_p_f_r_q_const__SbString_p_SbImage_p_void__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void = {"_p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void", "SoVRMLAnchorCB *|void (*)(SbString const &,void *,SoVRMLAnchor *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int = {"_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int", "VRMLPrequalifyFileCallback *|int (*)(SbString const &,void *,SoVRMLImageTexture *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp = {"_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void = {"_p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void", "SoVRMLInlineFetchURLCB *|void (*)(SbString const &,void *,SoVRMLInline *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void = {"_p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void", "SoWWWAnchorCB *|void (*)(SbString const &,void *,SoWWWAnchor *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbString_p_void_p_SoWWWInline__void = {"_p_f_r_q_const__SbString_p_void_p_SoWWWInline__void", "SoWWWInlineFetchURLCB *|void (*)(SbString const &,void *,SoWWWInline *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void = {"_p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void", "SbClipCallback *|void *(*)(SbVec3f const &,void *,SbVec3f const &,void *,SbVec3f const &,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void = {"_p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void", "SoVertexAttributeElement::AttributeApplyFunc *|void (*)(char const *const &,SoVertexAttributeData *const &,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_int_p_void__void = {"_p_f_unsigned_int_p_void__void", "SbDictApplyFunc *|SoContextHandler::ContextDestructionCB *|void (*)(unsigned int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_int_p_void_p_void__void = {"_p_f_unsigned_int_p_void_p_void__void", "SbDictApplyDataFunc *|void (*)(unsigned int,void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_void__p_void = {"_p_f_void__p_void", "SoType::instantiationMethod|void *(*)(void)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_floatp = {"_p_floatp", "floatp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "SbBool *|int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_longp = {"_p_longp", "longp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_open_func = {"_p_open_func", "open_func *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SbName = {"_p_p_SbName", "SbName **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SbString = {"_p_p_SbString", "SbString **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SbVec2f = {"_p_p_SbVec2f", "SbVec2f **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_ScXMLDataObj = {"_p_p_ScXMLDataObj", "ScXMLDataObj **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_ScXMLAddOpExprDataObj = {"_p_p_ScXMLAddOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLAndOpExprDataObj = {"_p_p_ScXMLAndOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLAppendOpExprDataObj = {"_p_p_ScXMLAppendOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLBoolDataObj = {"_p_p_ScXMLBoolDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinAddOpExprDataObj = {"_p_p_ScXMLCoinAddOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinDivideOpExprDataObj = {"_p_p_ScXMLCoinDivideOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinEqualsOpExprDataObj = {"_p_p_ScXMLCoinEqualsOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinLengthFuncExprDataObj = {"_p_p_ScXMLCoinLengthFuncExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinMultiplyOpExprDataObj = {"_p_p_ScXMLCoinMultiplyOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLCoinSubtractOpExprDataObj = {"_p_p_ScXMLCoinSubtractOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLConstantDataObj = {"_p_p_ScXMLConstantDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLDivideOpExprDataObj = {"_p_p_ScXMLDivideOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLEqualsOpExprDataObj = {"_p_p_ScXMLEqualsOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLExprDataObj = {"_p_p_ScXMLExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLInExprDataObj = {"_p_p_ScXMLInExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLMinimumExprDataObj = {"_p_p_ScXMLMinimumExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLMultiplyOpExprDataObj = {"_p_p_ScXMLMultiplyOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLNegateOpExprDataObj = {"_p_p_ScXMLNegateOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLNotOpExprDataObj = {"_p_p_ScXMLNotOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLOrOpExprDataObj = {"_p_p_ScXMLOrOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLRealDataObj = {"_p_p_ScXMLRealDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLReferenceDataObj = {"_p_p_ScXMLReferenceDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLSbDataObj = {"_p_p_ScXMLSbDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLStringDataObj = {"_p_p_ScXMLStringDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLSubtractOpExprDataObj = {"_p_p_ScXMLSubtractOpExprDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ScXMLXMLDataObj = {"_p_p_ScXMLXMLDataObj", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBase = {"_p_p_SoBase", "SoBase **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoAlphaTest = {"_p_p_SoAlphaTest", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoAnnotation = {"_p_p_SoAnnotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoAntiSquish = {"_p_p_SoAntiSquish", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoAppearanceKit = {"_p_p_SoAppearanceKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoArray = {"_p_p_SoArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoAsciiText = {"_p_p_SoAsciiText", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBaseColor = {"_p_p_SoBaseColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBaseKit = {"_p_p_SoBaseKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBlinker = {"_p_p_SoBlinker", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBoolOperation = {"_p_p_SoBoolOperation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBumpMap = {"_p_p_SoBumpMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBumpMapCoordinate = {"_p_p_SoBumpMapCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoBumpMapTransform = {"_p_p_SoBumpMapTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCacheHint = {"_p_p_SoCacheHint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCalculator = {"_p_p_SoCalculator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCallback = {"_p_p_SoCallback", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCamera = {"_p_p_SoCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCameraKit = {"_p_p_SoCameraKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCenterballDragger = {"_p_p_SoCenterballDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCenterballManip = {"_p_p_SoCenterballManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoClipPlane = {"_p_p_SoClipPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoClipPlaneManip = {"_p_p_SoClipPlaneManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoColorIndex = {"_p_p_SoColorIndex", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComplexity = {"_p_p_SoComplexity", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeMatrix = {"_p_p_SoComposeMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeRotation = {"_p_p_SoComposeRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeRotationFromTo = {"_p_p_SoComposeRotationFromTo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeVec2f = {"_p_p_SoComposeVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeVec3f = {"_p_p_SoComposeVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComposeVec4f = {"_p_p_SoComposeVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoComputeBoundingBox = {"_p_p_SoComputeBoundingBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoConcatenate = {"_p_p_SoConcatenate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCone = {"_p_p_SoCone", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCoordinate3 = {"_p_p_SoCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCoordinate4 = {"_p_p_SoCoordinate4", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCounter = {"_p_p_SoCounter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCube = {"_p_p_SoCube", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoCylinder = {"_p_p_SoCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDecomposeMatrix = {"_p_p_SoDecomposeMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDecomposeRotation = {"_p_p_SoDecomposeRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDecomposeVec2f = {"_p_p_SoDecomposeVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDecomposeVec3f = {"_p_p_SoDecomposeVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDecomposeVec4f = {"_p_p_SoDecomposeVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDepthBuffer = {"_p_p_SoDepthBuffer", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDirectionalLight = {"_p_p_SoDirectionalLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDirectionalLightDragger = {"_p_p_SoDirectionalLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDirectionalLightManip = {"_p_p_SoDirectionalLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDragPointDragger = {"_p_p_SoDragPointDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDragger = {"_p_p_SoDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoDrawStyle = {"_p_p_SoDrawStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoElapsedTime = {"_p_p_SoElapsedTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoEnvironment = {"_p_p_SoEnvironment", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoEventCallback = {"_p_p_SoEventCallback", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoExtSelection = {"_p_p_SoExtSelection", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFaceSet = {"_p_p_SoFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFieldContainer = {"_p_p_SoFieldContainer", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFieldConverter = {"_p_p_SoFieldConverter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFile = {"_p_p_SoFile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFont = {"_p_p_SoFont", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFontStyle = {"_p_p_SoFontStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFragmentShader = {"_p_p_SoFragmentShader", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFrustumCamera = {"_p_p_SoFrustumCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoFullPath = {"_p_p_SoFullPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGate = {"_p_p_SoGate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGeoCoordinate = {"_p_p_SoGeoCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGeoLocation = {"_p_p_SoGeoLocation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGeoOrigin = {"_p_p_SoGeoOrigin", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGeoSeparator = {"_p_p_SoGeoSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGroup = {"_p_p_SoGroup", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoHandleBoxDragger = {"_p_p_SoHandleBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoHandleBoxManip = {"_p_p_SoHandleBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoHeightMapToNormalMap = {"_p_p_SoHeightMapToNormalMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoImage = {"_p_p_SoImage", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedFaceSet = {"_p_p_SoIndexedFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedLineSet = {"_p_p_SoIndexedLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedMarkerSet = {"_p_p_SoIndexedMarkerSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedNurbsCurve = {"_p_p_SoIndexedNurbsCurve", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedNurbsSurface = {"_p_p_SoIndexedNurbsSurface", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedPointSet = {"_p_p_SoIndexedPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedShape = {"_p_p_SoIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoIndexedTriangleStripSet = {"_p_p_SoIndexedTriangleStripSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInfo = {"_p_p_SoInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInteractionKit = {"_p_p_SoInteractionKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolate = {"_p_p_SoInterpolate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolateFloat = {"_p_p_SoInterpolateFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolateRotation = {"_p_p_SoInterpolateRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolateVec2f = {"_p_p_SoInterpolateVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolateVec3f = {"_p_p_SoInterpolateVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoInterpolateVec4f = {"_p_p_SoInterpolateVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoJackDragger = {"_p_p_SoJackDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoJackManip = {"_p_p_SoJackManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLOD = {"_p_p_SoLOD", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLabel = {"_p_p_SoLabel", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLevelOfDetail = {"_p_p_SoLevelOfDetail", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLight = {"_p_p_SoLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLightKit = {"_p_p_SoLightKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLightModel = {"_p_p_SoLightModel", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLineSet = {"_p_p_SoLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLinearProfile = {"_p_p_SoLinearProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoListener = {"_p_p_SoListener", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLocateHighlight = {"_p_p_SoLocateHighlight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMarkerSet = {"_p_p_SoMarkerSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMaterial = {"_p_p_SoMaterial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMaterialBinding = {"_p_p_SoMaterialBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMatrixTransform = {"_p_p_SoMatrixTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMultipleCopy = {"_p_p_SoMultipleCopy", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNodeEngine = {"_p_p_SoNodeEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNodeKitListPart = {"_p_p_SoNodeKitListPart", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNodeKitPath = {"_p_p_SoNodeKitPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNonIndexedShape = {"_p_p_SoNonIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNormal = {"_p_p_SoNormal", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNormalBinding = {"_p_p_SoNormalBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNurbsCurve = {"_p_p_SoNurbsCurve", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNurbsProfile = {"_p_p_SoNurbsProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoNurbsSurface = {"_p_p_SoNurbsSurface", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoOnOff = {"_p_p_SoOnOff", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoOneShot = {"_p_p_SoOneShot", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoOrthographicCamera = {"_p_p_SoOrthographicCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPackedColor = {"_p_p_SoPackedColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPathSwitch = {"_p_p_SoPathSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPendulum = {"_p_p_SoPendulum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPerspectiveCamera = {"_p_p_SoPerspectiveCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPickStyle = {"_p_p_SoPickStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPointLight = {"_p_p_SoPointLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPointLightDragger = {"_p_p_SoPointLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPointLightManip = {"_p_p_SoPointLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPointSet = {"_p_p_SoPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoPolygonOffset = {"_p_p_SoPolygonOffset", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoProfile = {"_p_p_SoProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoProfileCoordinate2 = {"_p_p_SoProfileCoordinate2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoProfileCoordinate3 = {"_p_p_SoProfileCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoProto = {"_p_p_SoProto", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoProtoInstance = {"_p_p_SoProtoInstance", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoQuadMesh = {"_p_p_SoQuadMesh", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoResetTransform = {"_p_p_SoResetTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoReversePerspectiveCamera = {"_p_p_SoReversePerspectiveCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotateCylindricalDragger = {"_p_p_SoRotateCylindricalDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotateDiscDragger = {"_p_p_SoRotateDiscDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotateSphericalDragger = {"_p_p_SoRotateSphericalDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotation = {"_p_p_SoRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotationXYZ = {"_p_p_SoRotationXYZ", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoRotor = {"_p_p_SoRotor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoScale = {"_p_p_SoScale", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoScale1Dragger = {"_p_p_SoScale1Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoScale2Dragger = {"_p_p_SoScale2Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoScale2UniformDragger = {"_p_p_SoScale2UniformDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoScaleUniformDragger = {"_p_p_SoScaleUniformDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSceneKit = {"_p_p_SoSceneKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSceneTexture2 = {"_p_p_SoSceneTexture2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSceneTextureCubeMap = {"_p_p_SoSceneTextureCubeMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSelectOne = {"_p_p_SoSelectOne", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSelection = {"_p_p_SoSelection", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSeparator = {"_p_p_SoSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSeparatorKit = {"_p_p_SoSeparatorKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderObject = {"_p_p_SoShaderObject", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter = {"_p_p_SoShaderParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter1f = {"_p_p_SoShaderParameter1f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter1i = {"_p_p_SoShaderParameter1i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter2f = {"_p_p_SoShaderParameter2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter2i = {"_p_p_SoShaderParameter2i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter3f = {"_p_p_SoShaderParameter3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter3i = {"_p_p_SoShaderParameter3i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter4f = {"_p_p_SoShaderParameter4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameter4i = {"_p_p_SoShaderParameter4i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray1f = {"_p_p_SoShaderParameterArray1f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray1i = {"_p_p_SoShaderParameterArray1i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray2f = {"_p_p_SoShaderParameterArray2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray2i = {"_p_p_SoShaderParameterArray2i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray3f = {"_p_p_SoShaderParameterArray3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray3i = {"_p_p_SoShaderParameterArray3i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray4f = {"_p_p_SoShaderParameterArray4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterArray4i = {"_p_p_SoShaderParameterArray4i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterMatrix = {"_p_p_SoShaderParameterMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderParameterMatrixArray = {"_p_p_SoShaderParameterMatrixArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderProgram = {"_p_p_SoShaderProgram", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShaderStateMatrixParameter = {"_p_p_SoShaderStateMatrixParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShape = {"_p_p_SoShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShapeHints = {"_p_p_SoShapeHints", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShapeKit = {"_p_p_SoShapeKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoShuttle = {"_p_p_SoShuttle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSphere = {"_p_p_SoSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSpotLight = {"_p_p_SoSpotLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSpotLightDragger = {"_p_p_SoSpotLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSpotLightManip = {"_p_p_SoSpotLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSurroundScale = {"_p_p_SoSurroundScale", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSwitch = {"_p_p_SoSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTabBoxDragger = {"_p_p_SoTabBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTabBoxManip = {"_p_p_SoTabBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTabPlaneDragger = {"_p_p_SoTabPlaneDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTempPath = {"_p_p_SoTempPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoText2 = {"_p_p_SoText2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoText3 = {"_p_p_SoText3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture = {"_p_p_SoTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture2 = {"_p_p_SoTexture2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture2Convert = {"_p_p_SoTexture2Convert", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture2Transform = {"_p_p_SoTexture2Transform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture3 = {"_p_p_SoTexture3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTexture3Transform = {"_p_p_SoTexture3Transform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCombine = {"_p_p_SoTextureCombine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinate2 = {"_p_p_SoTextureCoordinate2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinate3 = {"_p_p_SoTextureCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateBinding = {"_p_p_SoTextureCoordinateBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateCube = {"_p_p_SoTextureCoordinateCube", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateCylinder = {"_p_p_SoTextureCoordinateCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateDefault = {"_p_p_SoTextureCoordinateDefault", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateEnvironment = {"_p_p_SoTextureCoordinateEnvironment", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateFunction = {"_p_p_SoTextureCoordinateFunction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateNormalMap = {"_p_p_SoTextureCoordinateNormalMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateObject = {"_p_p_SoTextureCoordinateObject", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinatePlane = {"_p_p_SoTextureCoordinatePlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateReflectionMap = {"_p_p_SoTextureCoordinateReflectionMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCoordinateSphere = {"_p_p_SoTextureCoordinateSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureCubeMap = {"_p_p_SoTextureCubeMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureMatrixTransform = {"_p_p_SoTextureMatrixTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureScalePolicy = {"_p_p_SoTextureScalePolicy", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTextureUnit = {"_p_p_SoTextureUnit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTimeCounter = {"_p_p_SoTimeCounter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTrackballDragger = {"_p_p_SoTrackballDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTrackballManip = {"_p_p_SoTrackballManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransform = {"_p_p_SoTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformBoxDragger = {"_p_p_SoTransformBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformBoxManip = {"_p_p_SoTransformBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformManip = {"_p_p_SoTransformManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformSeparator = {"_p_p_SoTransformSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformVec3f = {"_p_p_SoTransformVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformation = {"_p_p_SoTransformation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformerDragger = {"_p_p_SoTransformerDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransformerManip = {"_p_p_SoTransformerManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTranslate1Dragger = {"_p_p_SoTranslate1Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTranslate2Dragger = {"_p_p_SoTranslate2Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTranslation = {"_p_p_SoTranslation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTransparencyType = {"_p_p_SoTransparencyType", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTriangleStripSet = {"_p_p_SoTriangleStripSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoTriggerAny = {"_p_p_SoTriggerAny", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoUniformShaderParameter = {"_p_p_SoUniformShaderParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoUnits = {"_p_p_SoUnits", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLAnchor = {"_p_p_SoVRMLAnchor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLAppearance = {"_p_p_SoVRMLAppearance", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLAudioClip = {"_p_p_SoVRMLAudioClip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLBackground = {"_p_p_SoVRMLBackground", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLBillboard = {"_p_p_SoVRMLBillboard", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLBox = {"_p_p_SoVRMLBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCollision = {"_p_p_SoVRMLCollision", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLColor = {"_p_p_SoVRMLColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLColorInterpolator = {"_p_p_SoVRMLColorInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCone = {"_p_p_SoVRMLCone", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCoordinate = {"_p_p_SoVRMLCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCoordinateInterpolator = {"_p_p_SoVRMLCoordinateInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCylinder = {"_p_p_SoVRMLCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLCylinderSensor = {"_p_p_SoVRMLCylinderSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLDirectionalLight = {"_p_p_SoVRMLDirectionalLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLDragSensor = {"_p_p_SoVRMLDragSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLElevationGrid = {"_p_p_SoVRMLElevationGrid", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLExtrusion = {"_p_p_SoVRMLExtrusion", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLFog = {"_p_p_SoVRMLFog", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLFontStyle = {"_p_p_SoVRMLFontStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLGeometry = {"_p_p_SoVRMLGeometry", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLGroup = {"_p_p_SoVRMLGroup", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLImageTexture = {"_p_p_SoVRMLImageTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLIndexedFaceSet = {"_p_p_SoVRMLIndexedFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLIndexedLine = {"_p_p_SoVRMLIndexedLine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLIndexedLineSet = {"_p_p_SoVRMLIndexedLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLIndexedShape = {"_p_p_SoVRMLIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLInline = {"_p_p_SoVRMLInline", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLInterpolator = {"_p_p_SoVRMLInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLLOD = {"_p_p_SoVRMLLOD", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLLight = {"_p_p_SoVRMLLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLMaterial = {"_p_p_SoVRMLMaterial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLMovieTexture = {"_p_p_SoVRMLMovieTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLNavigationInfo = {"_p_p_SoVRMLNavigationInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLNormal = {"_p_p_SoVRMLNormal", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLNormalInterpolator = {"_p_p_SoVRMLNormalInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLOrientationInterpolator = {"_p_p_SoVRMLOrientationInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLParent = {"_p_p_SoVRMLParent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLPixelTexture = {"_p_p_SoVRMLPixelTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLPlaneSensor = {"_p_p_SoVRMLPlaneSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLPointLight = {"_p_p_SoVRMLPointLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLPointSet = {"_p_p_SoVRMLPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLPositionInterpolator = {"_p_p_SoVRMLPositionInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLProximitySensor = {"_p_p_SoVRMLProximitySensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLScalarInterpolator = {"_p_p_SoVRMLScalarInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLScript = {"_p_p_SoVRMLScript", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSensor = {"_p_p_SoVRMLSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLShape = {"_p_p_SoVRMLShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSound = {"_p_p_SoVRMLSound", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSphere = {"_p_p_SoVRMLSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSphereSensor = {"_p_p_SoVRMLSphereSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSpotLight = {"_p_p_SoVRMLSpotLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLSwitch = {"_p_p_SoVRMLSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLText = {"_p_p_SoVRMLText", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTexture = {"_p_p_SoVRMLTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTextureCoordinate = {"_p_p_SoVRMLTextureCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTextureTransform = {"_p_p_SoVRMLTextureTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTimeSensor = {"_p_p_SoVRMLTimeSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTouchSensor = {"_p_p_SoVRMLTouchSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLTransform = {"_p_p_SoVRMLTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLVertexLine = {"_p_p_SoVRMLVertexLine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLVertexPoint = {"_p_p_SoVRMLVertexPoint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLVertexShape = {"_p_p_SoVRMLVertexShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLViewpoint = {"_p_p_SoVRMLViewpoint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLVisibilitySensor = {"_p_p_SoVRMLVisibilitySensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVRMLWorldInfo = {"_p_p_SoVRMLWorldInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVertexAttribute = {"_p_p_SoVertexAttribute", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVertexAttributeBinding = {"_p_p_SoVertexAttributeBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVertexProperty = {"_p_p_SoVertexProperty", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVertexShader = {"_p_p_SoVertexShader", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoVertexShape = {"_p_p_SoVertexShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoWWWAnchor = {"_p_p_SoWWWAnchor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoWWWInline = {"_p_p_SoWWWInline", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoWrapperKit = {"_p_p_SoWrapperKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoEngine = {"_p_p_SoEngine", "SoEngine **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoEngineOutput = {"_p_p_SoEngineOutput", "SoEngineOutput **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoField = {"_p_p_SoField", "SoField **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoMFBitMask = {"_p_p_SoMFBitMask", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFBool = {"_p_p_SoMFBool", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFColor = {"_p_p_SoMFColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFColorRGBA = {"_p_p_SoMFColorRGBA", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFDouble = {"_p_p_SoMFDouble", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFEngine = {"_p_p_SoMFEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFEnum = {"_p_p_SoMFEnum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFFloat = {"_p_p_SoMFFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFInt32 = {"_p_p_SoMFInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFMatrix = {"_p_p_SoMFMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFName = {"_p_p_SoMFName", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFNode = {"_p_p_SoMFNode", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFPath = {"_p_p_SoMFPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFPlane = {"_p_p_SoMFPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFRotation = {"_p_p_SoMFRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFShort = {"_p_p_SoMFShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFString = {"_p_p_SoMFString", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFTime = {"_p_p_SoMFTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFUInt32 = {"_p_p_SoMFUInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFUShort = {"_p_p_SoMFUShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec2b = {"_p_p_SoMFVec2b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec2d = {"_p_p_SoMFVec2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec2f = {"_p_p_SoMFVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec2i32 = {"_p_p_SoMFVec2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec2s = {"_p_p_SoMFVec2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec3b = {"_p_p_SoMFVec3b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec3d = {"_p_p_SoMFVec3d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec3f = {"_p_p_SoMFVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec3i32 = {"_p_p_SoMFVec3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec3s = {"_p_p_SoMFVec3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4b = {"_p_p_SoMFVec4b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4d = {"_p_p_SoMFVec4d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4f = {"_p_p_SoMFVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4i32 = {"_p_p_SoMFVec4i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4s = {"_p_p_SoMFVec4s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4ub = {"_p_p_SoMFVec4ub", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4ui32 = {"_p_p_SoMFVec4ui32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMFVec4us = {"_p_p_SoMFVec4us", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBitMask = {"_p_p_SoSFBitMask", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBool = {"_p_p_SoSFBool", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox2d = {"_p_p_SoSFBox2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox2f = {"_p_p_SoSFBox2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox2i32 = {"_p_p_SoSFBox2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox2s = {"_p_p_SoSFBox2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox3d = {"_p_p_SoSFBox3d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox3f = {"_p_p_SoSFBox3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox3i32 = {"_p_p_SoSFBox3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFBox3s = {"_p_p_SoSFBox3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFColor = {"_p_p_SoSFColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFColorRGBA = {"_p_p_SoSFColorRGBA", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFDouble = {"_p_p_SoSFDouble", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFEngine = {"_p_p_SoSFEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFEnum = {"_p_p_SoSFEnum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFFloat = {"_p_p_SoSFFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFImage = {"_p_p_SoSFImage", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFImage3 = {"_p_p_SoSFImage3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFInt32 = {"_p_p_SoSFInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFMatrix = {"_p_p_SoSFMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFName = {"_p_p_SoSFName", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFNode = {"_p_p_SoSFNode", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFPath = {"_p_p_SoSFPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFPlane = {"_p_p_SoSFPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFRotation = {"_p_p_SoSFRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFShort = {"_p_p_SoSFShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFString = {"_p_p_SoSFString", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFTime = {"_p_p_SoSFTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFTrigger = {"_p_p_SoSFTrigger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFUInt32 = {"_p_p_SoSFUInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFUShort = {"_p_p_SoSFUShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec2b = {"_p_p_SoSFVec2b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec2d = {"_p_p_SoSFVec2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec2f = {"_p_p_SoSFVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec2i32 = {"_p_p_SoSFVec2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec2s = {"_p_p_SoSFVec2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec3b = {"_p_p_SoSFVec3b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec3d = {"_p_p_SoSFVec3d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec3f = {"_p_p_SoSFVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec3i32 = {"_p_p_SoSFVec3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec3s = {"_p_p_SoSFVec3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4b = {"_p_p_SoSFVec4b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4d = {"_p_p_SoSFVec4d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4f = {"_p_p_SoSFVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4i32 = {"_p_p_SoSFVec4i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4s = {"_p_p_SoSFVec4s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4ub = {"_p_p_SoSFVec4ub", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4ui32 = {"_p_p_SoSFVec4ui32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSFVec4us = {"_p_p_SoSFVec4us", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoSField = {"_p_p_SoSField", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoGLRenderAction = {"_p_p_SoGLRenderAction", "SoGLRenderAction **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoBoxHighlightRenderAction = {"_p_p_SoBoxHighlightRenderAction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoLineHighlightRenderAction = {"_p_p_SoLineHighlightRenderAction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_SoMField = {"_p_p_SoMField", "SoMField **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoNode = {"_p_p_SoNode", "SoNode **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SoPath = {"_p_p_SoPath", "SoPath **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_charp = {"_p_p_charp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_f_p_SoAction_p_SoNode__void = {"_p_p_f_p_SoAction_p_SoNode__void", "SoActionMethod *|void (**)(SoAction *,SoNode *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void__SoGLRenderAction__AbortCode = {"_p_p_f_p_void__SoGLRenderAction__AbortCode", "SoGLRenderAction::SoGLRenderAbortCB **|enum SoGLRenderAction::AbortCode (**)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_SoInput__void = {"_p_p_f_p_void_p_SoInput__void", "SoDBHeaderCB **|void (**)(void *,SoInput *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_floatp = {"_p_p_floatp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_intp = {"_p_p_intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "unsigned char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_read_func = {"_p_read_func", "read_func *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_seek_func = {"_p_seek_func", "seek_func *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__FILE = {"_p_std__FILE", "std::FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_tell_func = {"_p_tell_func", "tell_func *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_timeval = {"_p_timeval", "timeval *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "SbDictKeyType *|uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "SbUniqueId *|uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "wchar_t *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_AttributeApplyFunc,
  &_swigt__p_ContextDestructionCB,
  &_swigt__p_FILE,
  &_swigt__p_Key,
  &_swigt__p_ProgressCallbackType,
  &_swigt__p_SbBSPTree,
  &_swigt__p_SbBarrier,
  &_swigt__p_SbBox2d,
  &_swigt__p_SbBox2f,
  &_swigt__p_SbBox2i32,
  &_swigt__p_SbBox2s,
  &_swigt__p_SbBox3d,
  &_swigt__p_SbBox3f,
  &_swigt__p_SbBox3i32,
  &_swigt__p_SbBox3s,
  &_swigt__p_SbByteBuffer,
  &_swigt__p_SbClip,
  &_swigt__p_SbColor,
  &_swigt__p_SbColor4f,
  &_swigt__p_SbCondVar,
  &_swigt__p_SbCylinder,
  &_swigt__p_SbCylinderPlaneProjector,
  &_swigt__p_SbCylinderProjector,
  &_swigt__p_SbCylinderSectionProjector,
  &_swigt__p_SbCylinderSheetProjector,
  &_swigt__p_SbDPLine,
  &_swigt__p_SbDPMatrix,
  &_swigt__p_SbDPPlane,
  &_swigt__p_SbDPRotation,
  &_swigt__p_SbDPViewVolume,
  &_swigt__p_SbDict,
  &_swigt__p_SbFifo,
  &_swigt__p_SbHeap,
  &_swigt__p_SbHeapFuncs,
  &_swigt__p_SbImage,
  &_swigt__p_SbIntList,
  &_swigt__p_SbLine,
  &_swigt__p_SbLineProjector,
  &_swigt__p_SbListT_SbString_t,
  &_swigt__p_SbListT_char_const_p_t,
  &_swigt__p_SbListT_int_t,
  &_swigt__p_SbListT_void_p_t,
  &_swigt__p_SbMatrix,
  &_swigt__p_SbMutex,
  &_swigt__p_SbName,
  &_swigt__p_SbOctTree,
  &_swigt__p_SbOctTreeFuncs,
  &_swigt__p_SbPList,
  &_swigt__p_SbPlane,
  &_swigt__p_SbPlaneProjector,
  &_swigt__p_SbProjector,
  &_swigt__p_SbRWMutex,
  &_swigt__p_SbRotation,
  &_swigt__p_SbSphere,
  &_swigt__p_SbSpherePlaneProjector,
  &_swigt__p_SbSphereProjector,
  &_swigt__p_SbSphereSectionProjector,
  &_swigt__p_SbSphereSheetProjector,
  &_swigt__p_SbStorage,
  &_swigt__p_SbString,
  &_swigt__p_SbStringList,
  &_swigt__p_SbTesselator,
  &_swigt__p_SbThread,
  &_swigt__p_SbThreadAutoLock,
  &_swigt__p_SbThreadMutex,
  &_swigt__p_SbTime,
  &_swigt__p_SbVec2b,
  &_swigt__p_SbVec2d,
  &_swigt__p_SbVec2f,
  &_swigt__p_SbVec2i32,
  &_swigt__p_SbVec2s,
  &_swigt__p_SbVec2ub,
  &_swigt__p_SbVec2ui32,
  &_swigt__p_SbVec2us,
  &_swigt__p_SbVec3b,
  &_swigt__p_SbVec3d,
  &_swigt__p_SbVec3f,
  &_swigt__p_SbVec3fList,
  &_swigt__p_SbVec3i32,
  &_swigt__p_SbVec3s,
  &_swigt__p_SbVec3ub,
  &_swigt__p_SbVec3ui32,
  &_swigt__p_SbVec3us,
  &_swigt__p_SbVec4b,
  &_swigt__p_SbVec4d,
  &_swigt__p_SbVec4f,
  &_swigt__p_SbVec4i32,
  &_swigt__p_SbVec4s,
  &_swigt__p_SbVec4ub,
  &_swigt__p_SbVec4ui32,
  &_swigt__p_SbVec4us,
  &_swigt__p_SbViewVolume,
  &_swigt__p_SbViewportRegion,
  &_swigt__p_SbXfBox3f,
  &_swigt__p_ScXML,
  &_swigt__p_ScXMLAbstractStateElt,
  &_swigt__p_ScXMLAddOpExprDataObj,
  &_swigt__p_ScXMLAnchorElt,
  &_swigt__p_ScXMLAndOpExprDataObj,
  &_swigt__p_ScXMLAppendOpExprDataObj,
  &_swigt__p_ScXMLAssignElt,
  &_swigt__p_ScXMLBoolDataObj,
  &_swigt__p_ScXMLCoinAddOpExprDataObj,
  &_swigt__p_ScXMLCoinDivideOpExprDataObj,
  &_swigt__p_ScXMLCoinEqualsOpExprDataObj,
  &_swigt__p_ScXMLCoinEvaluator,
  &_swigt__p_ScXMLCoinLengthFuncExprDataObj,
  &_swigt__p_ScXMLCoinMultiplyOpExprDataObj,
  &_swigt__p_ScXMLCoinSubtractOpExprDataObj,
  &_swigt__p_ScXMLConstantDataObj,
  &_swigt__p_ScXMLContentElt,
  &_swigt__p_ScXMLDataElt,
  &_swigt__p_ScXMLDataModelElt,
  &_swigt__p_ScXMLDataObj,
  &_swigt__p_ScXMLDivideOpExprDataObj,
  &_swigt__p_ScXMLDocument,
  &_swigt__p_ScXMLECMAScriptEvaluator,
  &_swigt__p_ScXMLElseElt,
  &_swigt__p_ScXMLElseIfElt,
  &_swigt__p_ScXMLElt,
  &_swigt__p_ScXMLEltReader,
  &_swigt__p_ScXMLEqualsOpExprDataObj,
  &_swigt__p_ScXMLEvaluator,
  &_swigt__p_ScXMLEvent,
  &_swigt__p_ScXMLEventElt,
  &_swigt__p_ScXMLEventTarget,
  &_swigt__p_ScXMLExecutableElt,
  &_swigt__p_ScXMLExprDataObj,
  &_swigt__p_ScXMLFinalElt,
  &_swigt__p_ScXMLFinalizeElt,
  &_swigt__p_ScXMLHistoryElt,
  &_swigt__p_ScXMLIfElt,
  &_swigt__p_ScXMLInExprDataObj,
  &_swigt__p_ScXMLInitialElt,
  &_swigt__p_ScXMLInvokeElt,
  &_swigt__p_ScXMLLogElt,
  &_swigt__p_ScXMLMinimumEvaluator,
  &_swigt__p_ScXMLMinimumExprDataObj,
  &_swigt__p_ScXMLMultiplyOpExprDataObj,
  &_swigt__p_ScXMLNegateOpExprDataObj,
  &_swigt__p_ScXMLNotOpExprDataObj,
  &_swigt__p_ScXMLObject,
  &_swigt__p_ScXMLOnEntryElt,
  &_swigt__p_ScXMLOnExitElt,
  &_swigt__p_ScXMLOrOpExprDataObj,
  &_swigt__p_ScXMLParallelElt,
  &_swigt__p_ScXMLParamElt,
  &_swigt__p_ScXMLRealDataObj,
  &_swigt__p_ScXMLReferenceDataObj,
  &_swigt__p_ScXMLSbDataObj,
  &_swigt__p_ScXMLScriptElt,
  &_swigt__p_ScXMLScxmlElt,
  &_swigt__p_ScXMLSendElt,
  &_swigt__p_ScXMLStateElt,
  &_swigt__p_ScXMLStateMachine,
  &_swigt__p_ScXMLStringDataObj,
  &_swigt__p_ScXMLSubtractOpExprDataObj,
  &_swigt__p_ScXMLTransitionElt,
  &_swigt__p_ScXMLValidateElt,
  &_swigt__p_ScXMLXMLDataObj,
  &_swigt__p_ScXMLXPathEvaluator,
  &_swigt__p_SoAccumulatedElement,
  &_swigt__p_SoAction,
  &_swigt__p_SoActionMethodList,
  &_swigt__p_SoAlarmSensor,
  &_swigt__p_SoAlphaTest,
  &_swigt__p_SoAmbientColorElement,
  &_swigt__p_SoAnnoText3CharOrientElement,
  &_swigt__p_SoAnnoText3FontSizeHintElement,
  &_swigt__p_SoAnnoText3RenderPrintElement,
  &_swigt__p_SoAnnotation,
  &_swigt__p_SoAntiSquish,
  &_swigt__p_SoAppearanceKit,
  &_swigt__p_SoArray,
  &_swigt__p_SoAsciiText,
  &_swigt__p_SoAudioDevice,
  &_swigt__p_SoAudioRenderAction,
  &_swigt__p_SoAuditorList,
  &_swigt__p_SoBBoxModelMatrixElement,
  &_swigt__p_SoBase,
  &_swigt__p_SoBaseColor,
  &_swigt__p_SoBaseKit,
  &_swigt__p_SoBaseList,
  &_swigt__p_SoBlinker,
  &_swigt__p_SoBoolOperation,
  &_swigt__p_SoBoundingBoxCache,
  &_swigt__p_SoBoxHighlightRenderAction,
  &_swigt__p_SoBumpMap,
  &_swigt__p_SoBumpMapCoordinate,
  &_swigt__p_SoBumpMapCoordinateElement,
  &_swigt__p_SoBumpMapElement,
  &_swigt__p_SoBumpMapMatrixElement,
  &_swigt__p_SoBumpMapTransform,
  &_swigt__p_SoBundle,
  &_swigt__p_SoButtonEvent,
  &_swigt__p_SoByteStream,
  &_swigt__p_SoCache,
  &_swigt__p_SoCacheElement,
  &_swigt__p_SoCacheHint,
  &_swigt__p_SoCacheHintElement,
  &_swigt__p_SoCalculator,
  &_swigt__p_SoCallback,
  &_swigt__p_SoCallbackAction,
  &_swigt__p_SoCallbackActionCB,
  &_swigt__p_SoCallbackList,
  &_swigt__p_SoCamera,
  &_swigt__p_SoCameraKit,
  &_swigt__p_SoCenterballDragger,
  &_swigt__p_SoCenterballManip,
  &_swigt__p_SoChildList,
  &_swigt__p_SoClipPlane,
  &_swigt__p_SoClipPlaneElement,
  &_swigt__p_SoClipPlaneManip,
  &_swigt__p_SoColorIndex,
  &_swigt__p_SoColorPacker,
  &_swigt__p_SoComplexity,
  &_swigt__p_SoComplexityElement,
  &_swigt__p_SoComplexityTypeElement,
  &_swigt__p_SoComposeMatrix,
  &_swigt__p_SoComposeRotation,
  &_swigt__p_SoComposeRotationFromTo,
  &_swigt__p_SoComposeVec2f,
  &_swigt__p_SoComposeVec3f,
  &_swigt__p_SoComposeVec4f,
  &_swigt__p_SoComputeBoundingBox,
  &_swigt__p_SoConcatenate,
  &_swigt__p_SoCone,
  &_swigt__p_SoConeDetail,
  &_swigt__p_SoContextHandler,
  &_swigt__p_SoConvexDataCache,
  &_swigt__p_SoCoordinate3,
  &_swigt__p_SoCoordinate4,
  &_swigt__p_SoCoordinateElement,
  &_swigt__p_SoCounter,
  &_swigt__p_SoCreaseAngleElement,
  &_swigt__p_SoCube,
  &_swigt__p_SoCubeDetail,
  &_swigt__p_SoCullElement,
  &_swigt__p_SoCylinder,
  &_swigt__p_SoCylinderDetail,
  &_swigt__p_SoDB,
  &_swigt__p_SoDataSensor,
  &_swigt__p_SoDebugError,
  &_swigt__p_SoDecimationPercentageElement,
  &_swigt__p_SoDecimationTypeElement,
  &_swigt__p_SoDecomposeMatrix,
  &_swigt__p_SoDecomposeRotation,
  &_swigt__p_SoDecomposeVec2f,
  &_swigt__p_SoDecomposeVec3f,
  &_swigt__p_SoDecomposeVec4f,
  &_swigt__p_SoDelayQueueSensor,
  &_swigt__p_SoDepthBuffer,
  &_swigt__p_SoDepthBufferElement,
  &_swigt__p_SoDepthBufferElement__DepthWriteFunction,
  &_swigt__p_SoDetail,
  &_swigt__p_SoDetailList,
  &_swigt__p_SoDiffuseColorElement,
  &_swigt__p_SoDirectionalLight,
  &_swigt__p_SoDirectionalLightDragger,
  &_swigt__p_SoDirectionalLightManip,
  &_swigt__p_SoDragPointDragger,
  &_swigt__p_SoDragger,
  &_swigt__p_SoDrawStyle,
  &_swigt__p_SoDrawStyleElement,
  &_swigt__p_SoElapsedTime,
  &_swigt__p_SoElement,
  &_swigt__p_SoEmissiveColorElement,
  &_swigt__p_SoEnabledElementsList,
  &_swigt__p_SoEngine,
  &_swigt__p_SoEngineList,
  &_swigt__p_SoEngineOutput,
  &_swigt__p_SoEngineOutputData,
  &_swigt__p_SoEngineOutputList,
  &_swigt__p_SoEnvironment,
  &_swigt__p_SoEnvironmentElement,
  &_swigt__p_SoError,
  &_swigt__p_SoEvent,
  &_swigt__p_SoEventCallback,
  &_swigt__p_SoEventManager,
  &_swigt__p_SoExtSelection,
  &_swigt__p_SoFaceDetail,
  &_swigt__p_SoFaceSet,
  &_swigt__p_SoField,
  &_swigt__p_SoFieldContainer,
  &_swigt__p_SoFieldConverter,
  &_swigt__p_SoFieldData,
  &_swigt__p_SoFieldList,
  &_swigt__p_SoFieldSensor,
  &_swigt__p_SoFile,
  &_swigt__p_SoFloatElement,
  &_swigt__p_SoFocalDistanceElement,
  &_swigt__p_SoFont,
  &_swigt__p_SoFontNameElement,
  &_swigt__p_SoFontSizeElement,
  &_swigt__p_SoFontStyle,
  &_swigt__p_SoFragmentShader,
  &_swigt__p_SoFrustumCamera,
  &_swigt__p_SoFullPath,
  &_swigt__p_SoGLBigImage,
  &_swigt__p_SoGLCacheContextElement,
  &_swigt__p_SoGLCacheList,
  &_swigt__p_SoGLClipPlaneElement,
  &_swigt__p_SoGLColorIndexElement,
  &_swigt__p_SoGLCoordinateElement,
  &_swigt__p_SoGLDepthBufferElement,
  &_swigt__p_SoGLDisplayList,
  &_swigt__p_SoGLDrawStyleElement,
  &_swigt__p_SoGLEnvironmentElement,
  &_swigt__p_SoGLImage,
  &_swigt__p_SoGLImageResizeCB,
  &_swigt__p_SoGLLazyElement,
  &_swigt__p_SoGLLazyElement__GLState,
  &_swigt__p_SoGLLightIdElement,
  &_swigt__p_SoGLLinePatternElement,
  &_swigt__p_SoGLLineWidthElement,
  &_swigt__p_SoGLModelMatrixElement,
  &_swigt__p_SoGLMultiTextureCoordinateElement,
  &_swigt__p_SoGLMultiTextureEnabledElement,
  &_swigt__p_SoGLMultiTextureImageElement,
  &_swigt__p_SoGLMultiTextureMatrixElement,
  &_swigt__p_SoGLNormalElement,
  &_swigt__p_SoGLPointSizeElement,
  &_swigt__p_SoGLPolygonOffsetElement,
  &_swigt__p_SoGLProjectionMatrixElement,
  &_swigt__p_SoGLRenderAbortCB,
  &_swigt__p_SoGLRenderAction,
  &_swigt__p_SoGLRenderCache,
  &_swigt__p_SoGLRenderPassElement,
  &_swigt__p_SoGLShaderObject,
  &_swigt__p_SoGLShapeHintsElement,
  &_swigt__p_SoGLUpdateAreaElement,
  &_swigt__p_SoGLVBOElement,
  &_swigt__p_SoGLVertexAttributeElement,
  &_swigt__p_SoGLViewingMatrixElement,
  &_swigt__p_SoGLViewportRegionElement,
  &_swigt__p_SoGate,
  &_swigt__p_SoGeo,
  &_swigt__p_SoGeoCoordinate,
  &_swigt__p_SoGeoLocation,
  &_swigt__p_SoGeoOrigin,
  &_swigt__p_SoGeoSeparator,
  &_swigt__p_SoGetBoundingBoxAction,
  &_swigt__p_SoGetMatrixAction,
  &_swigt__p_SoGetPrimitiveCountAction,
  &_swigt__p_SoGlyph,
  &_swigt__p_SoGroup,
  &_swigt__p_SoHandleBoxDragger,
  &_swigt__p_SoHandleBoxManip,
  &_swigt__p_SoHandleEventAction,
  &_swigt__p_SoHardCopy,
  &_swigt__p_SoHeightMapToNormalMap,
  &_swigt__p_SoIdleSensor,
  &_swigt__p_SoImage,
  &_swigt__p_SoIndexedFaceSet,
  &_swigt__p_SoIndexedLineSet,
  &_swigt__p_SoIndexedMarkerSet,
  &_swigt__p_SoIndexedNurbsCurve,
  &_swigt__p_SoIndexedNurbsSurface,
  &_swigt__p_SoIndexedPointSet,
  &_swigt__p_SoIndexedShape,
  &_swigt__p_SoIndexedTriangleStripSet,
  &_swigt__p_SoInfo,
  &_swigt__p_SoInput,
  &_swigt__p_SoInt32Element,
  &_swigt__p_SoInteraction,
  &_swigt__p_SoInteractionKit,
  &_swigt__p_SoInterpolate,
  &_swigt__p_SoInterpolateFloat,
  &_swigt__p_SoInterpolateRotation,
  &_swigt__p_SoInterpolateVec2f,
  &_swigt__p_SoInterpolateVec3f,
  &_swigt__p_SoInterpolateVec4f,
  &_swigt__p_SoIntersectingPrimitive,
  &_swigt__p_SoIntersectionCB,
  &_swigt__p_SoIntersectionDetectionAction,
  &_swigt__p_SoIntersectionFilterCB,
  &_swigt__p_SoIntersectionVisitationCB,
  &_swigt__p_SoJackDragger,
  &_swigt__p_SoJackManip,
  &_swigt__p_SoKeyboardEvent,
  &_swigt__p_SoLOD,
  &_swigt__p_SoLabel,
  &_swigt__p_SoLazyElement,
  &_swigt__p_SoLevelOfDetail,
  &_swigt__p_SoLight,
  &_swigt__p_SoLightAttenuationElement,
  &_swigt__p_SoLightElement,
  &_swigt__p_SoLightKit,
  &_swigt__p_SoLightModel,
  &_swigt__p_SoLightModelElement,
  &_swigt__p_SoLightPath,
  &_swigt__p_SoLineDetail,
  &_swigt__p_SoLineHighlightRenderAction,
  &_swigt__p_SoLinePatternElement,
  &_swigt__p_SoLineSet,
  &_swigt__p_SoLineWidthElement,
  &_swigt__p_SoLinearProfile,
  &_swigt__p_SoListener,
  &_swigt__p_SoListenerDopplerElement,
  &_swigt__p_SoListenerGainElement,
  &_swigt__p_SoListenerOrientationElement,
  &_swigt__p_SoListenerPositionElement,
  &_swigt__p_SoLocalBBoxMatrixElement,
  &_swigt__p_SoLocateHighlight,
  &_swigt__p_SoLocation2Event,
  &_swigt__p_SoLockManager,
  &_swigt__p_SoMFBitMask,
  &_swigt__p_SoMFBool,
  &_swigt__p_SoMFColor,
  &_swigt__p_SoMFColorRGBA,
  &_swigt__p_SoMFDouble,
  &_swigt__p_SoMFEngine,
  &_swigt__p_SoMFEnum,
  &_swigt__p_SoMFFloat,
  &_swigt__p_SoMFInt32,
  &_swigt__p_SoMFMatrix,
  &_swigt__p_SoMFName,
  &_swigt__p_SoMFNode,
  &_swigt__p_SoMFPath,
  &_swigt__p_SoMFPlane,
  &_swigt__p_SoMFRotation,
  &_swigt__p_SoMFShort,
  &_swigt__p_SoMFString,
  &_swigt__p_SoMFTime,
  &_swigt__p_SoMFUInt32,
  &_swigt__p_SoMFUShort,
  &_swigt__p_SoMFVec2b,
  &_swigt__p_SoMFVec2d,
  &_swigt__p_SoMFVec2f,
  &_swigt__p_SoMFVec2i32,
  &_swigt__p_SoMFVec2s,
  &_swigt__p_SoMFVec3b,
  &_swigt__p_SoMFVec3d,
  &_swigt__p_SoMFVec3f,
  &_swigt__p_SoMFVec3i32,
  &_swigt__p_SoMFVec3s,
  &_swigt__p_SoMFVec4b,
  &_swigt__p_SoMFVec4d,
  &_swigt__p_SoMFVec4f,
  &_swigt__p_SoMFVec4i32,
  &_swigt__p_SoMFVec4s,
  &_swigt__p_SoMFVec4ub,
  &_swigt__p_SoMFVec4ui32,
  &_swigt__p_SoMFVec4us,
  &_swigt__p_SoMField,
  &_swigt__p_SoMarkerSet,
  &_swigt__p_SoMaterial,
  &_swigt__p_SoMaterialBinding,
  &_swigt__p_SoMaterialBindingElement,
  &_swigt__p_SoMaterialBundle,
  &_swigt__p_SoMatrixTransform,
  &_swigt__p_SoMemoryError,
  &_swigt__p_SoModelMatrixElement,
  &_swigt__p_SoMotion3Event,
  &_swigt__p_SoMouseButtonEvent,
  &_swigt__p_SoMultiTextureCoordinateElement,
  &_swigt__p_SoMultiTextureEnabledElement,
  &_swigt__p_SoMultiTextureEnabledElement__Mode,
  &_swigt__p_SoMultiTextureImageElement,
  &_swigt__p_SoMultiTextureImageElement__Model,
  &_swigt__p_SoMultiTextureImageElement__Wrap,
  &_swigt__p_SoMultiTextureMatrixElement,
  &_swigt__p_SoMultipleCopy,
  &_swigt__p_SoNode,
  &_swigt__p_SoNodeEngine,
  &_swigt__p_SoNodeKit,
  &_swigt__p_SoNodeKitDetail,
  &_swigt__p_SoNodeKitListPart,
  &_swigt__p_SoNodeKitPath,
  &_swigt__p_SoNodeList,
  &_swigt__p_SoNodeSensor,
  &_swigt__p_SoNodekitCatalog,
  &_swigt__p_SoNonIndexedShape,
  &_swigt__p_SoNormal,
  &_swigt__p_SoNormalBinding,
  &_swigt__p_SoNormalBindingElement,
  &_swigt__p_SoNormalBundle,
  &_swigt__p_SoNormalCache,
  &_swigt__p_SoNormalElement,
  &_swigt__p_SoNormalGenerator,
  &_swigt__p_SoNotList,
  &_swigt__p_SoNotRec,
  &_swigt__p_SoNurbsCurve,
  &_swigt__p_SoNurbsProfile,
  &_swigt__p_SoNurbsSurface,
  &_swigt__p_SoOffscreenRenderer,
  &_swigt__p_SoOnOff,
  &_swigt__p_SoOneShot,
  &_swigt__p_SoOneShotSensor,
  &_swigt__p_SoOrthographicCamera,
  &_swigt__p_SoOutput,
  &_swigt__p_SoOverrideElement,
  &_swigt__p_SoPSVectorOutput,
  &_swigt__p_SoPackedColor,
  &_swigt__p_SoPath,
  &_swigt__p_SoPathList,
  &_swigt__p_SoPathSensor,
  &_swigt__p_SoPathSwitch,
  &_swigt__p_SoPendulum,
  &_swigt__p_SoPerspectiveCamera,
  &_swigt__p_SoPickAction,
  &_swigt__p_SoPickRayElement,
  &_swigt__p_SoPickStyle,
  &_swigt__p_SoPickStyleElement,
  &_swigt__p_SoPickedPoint,
  &_swigt__p_SoPickedPointList,
  &_swigt__p_SoPointDetail,
  &_swigt__p_SoPointLight,
  &_swigt__p_SoPointLightDragger,
  &_swigt__p_SoPointLightManip,
  &_swigt__p_SoPointSet,
  &_swigt__p_SoPointSizeElement,
  &_swigt__p_SoPolygonOffset,
  &_swigt__p_SoPolygonOffsetElement,
  &_swigt__p_SoPolygonOffsetElement__Style,
  &_swigt__p_SoPrimitiveVertex,
  &_swigt__p_SoProfile,
  &_swigt__p_SoProfileCoordinate2,
  &_swigt__p_SoProfileCoordinate3,
  &_swigt__p_SoProfileCoordinateElement,
  &_swigt__p_SoProfileElement,
  &_swigt__p_SoProjectionMatrixElement,
  &_swigt__p_SoProto,
  &_swigt__p_SoProtoInstance,
  &_swigt__p_SoQuadMesh,
  &_swigt__p_SoRayPickAction,
  &_swigt__p_SoReadError,
  &_swigt__p_SoRenderManager,
  &_swigt__p_SoRenderManager__Superimposition,
  &_swigt__p_SoReorganizeAction,
  &_swigt__p_SoReplacedElement,
  &_swigt__p_SoResetTransform,
  &_swigt__p_SoReversePerspectiveCamera,
  &_swigt__p_SoRotateCylindricalDragger,
  &_swigt__p_SoRotateDiscDragger,
  &_swigt__p_SoRotateSphericalDragger,
  &_swigt__p_SoRotation,
  &_swigt__p_SoRotationXYZ,
  &_swigt__p_SoRotor,
  &_swigt__p_SoSFBitMask,
  &_swigt__p_SoSFBool,
  &_swigt__p_SoSFBox2d,
  &_swigt__p_SoSFBox2f,
  &_swigt__p_SoSFBox2i32,
  &_swigt__p_SoSFBox2s,
  &_swigt__p_SoSFBox3d,
  &_swigt__p_SoSFBox3f,
  &_swigt__p_SoSFBox3i32,
  &_swigt__p_SoSFBox3s,
  &_swigt__p_SoSFColor,
  &_swigt__p_SoSFColorRGBA,
  &_swigt__p_SoSFDouble,
  &_swigt__p_SoSFEngine,
  &_swigt__p_SoSFEnum,
  &_swigt__p_SoSFFloat,
  &_swigt__p_SoSFImage,
  &_swigt__p_SoSFImage3,
  &_swigt__p_SoSFInt32,
  &_swigt__p_SoSFMatrix,
  &_swigt__p_SoSFName,
  &_swigt__p_SoSFNode,
  &_swigt__p_SoSFPath,
  &_swigt__p_SoSFPlane,
  &_swigt__p_SoSFRotation,
  &_swigt__p_SoSFShort,
  &_swigt__p_SoSFString,
  &_swigt__p_SoSFTime,
  &_swigt__p_SoSFTrigger,
  &_swigt__p_SoSFUInt32,
  &_swigt__p_SoSFUShort,
  &_swigt__p_SoSFVec2b,
  &_swigt__p_SoSFVec2d,
  &_swigt__p_SoSFVec2f,
  &_swigt__p_SoSFVec2i32,
  &_swigt__p_SoSFVec2s,
  &_swigt__p_SoSFVec3b,
  &_swigt__p_SoSFVec3d,
  &_swigt__p_SoSFVec3f,
  &_swigt__p_SoSFVec3i32,
  &_swigt__p_SoSFVec3s,
  &_swigt__p_SoSFVec4b,
  &_swigt__p_SoSFVec4d,
  &_swigt__p_SoSFVec4f,
  &_swigt__p_SoSFVec4i32,
  &_swigt__p_SoSFVec4s,
  &_swigt__p_SoSFVec4ub,
  &_swigt__p_SoSFVec4ui32,
  &_swigt__p_SoSFVec4us,
  &_swigt__p_SoSField,
  &_swigt__p_SoScXMLDollyTarget,
  &_swigt__p_SoScXMLEvent,
  &_swigt__p_SoScXMLFlightControlTarget,
  &_swigt__p_SoScXMLMiscTarget,
  &_swigt__p_SoScXMLMotionTarget,
  &_swigt__p_SoScXMLNavigation,
  &_swigt__p_SoScXMLNavigationTarget,
  &_swigt__p_SoScXMLPanTarget,
  &_swigt__p_SoScXMLRotateTarget,
  &_swigt__p_SoScXMLSeekTarget,
  &_swigt__p_SoScXMLSpinTarget,
  &_swigt__p_SoScXMLStateMachine,
  &_swigt__p_SoScXMLZoomTarget,
  &_swigt__p_SoScale,
  &_swigt__p_SoScale1Dragger,
  &_swigt__p_SoScale2Dragger,
  &_swigt__p_SoScale2UniformDragger,
  &_swigt__p_SoScaleUniformDragger,
  &_swigt__p_SoSceneKit,
  &_swigt__p_SoSceneManager,
  &_swigt__p_SoSceneTexture2,
  &_swigt__p_SoSceneTextureCubeMap,
  &_swigt__p_SoSearchAction,
  &_swigt__p_SoSelectOne,
  &_swigt__p_SoSelection,
  &_swigt__p_SoSensor,
  &_swigt__p_SoSensorManager,
  &_swigt__p_SoSeparator,
  &_swigt__p_SoSeparatorKit,
  &_swigt__p_SoShaderObject,
  &_swigt__p_SoShaderParameter,
  &_swigt__p_SoShaderParameter1f,
  &_swigt__p_SoShaderParameter1i,
  &_swigt__p_SoShaderParameter2f,
  &_swigt__p_SoShaderParameter2i,
  &_swigt__p_SoShaderParameter3f,
  &_swigt__p_SoShaderParameter3i,
  &_swigt__p_SoShaderParameter4f,
  &_swigt__p_SoShaderParameter4i,
  &_swigt__p_SoShaderParameterArray1f,
  &_swigt__p_SoShaderParameterArray1i,
  &_swigt__p_SoShaderParameterArray2f,
  &_swigt__p_SoShaderParameterArray2i,
  &_swigt__p_SoShaderParameterArray3f,
  &_swigt__p_SoShaderParameterArray3i,
  &_swigt__p_SoShaderParameterArray4f,
  &_swigt__p_SoShaderParameterArray4i,
  &_swigt__p_SoShaderParameterMatrix,
  &_swigt__p_SoShaderParameterMatrixArray,
  &_swigt__p_SoShaderProgram,
  &_swigt__p_SoShaderStateMatrixParameter,
  &_swigt__p_SoShape,
  &_swigt__p_SoShapeHints,
  &_swigt__p_SoShapeHintsElement,
  &_swigt__p_SoShapeHintsElement__FaceType,
  &_swigt__p_SoShapeHintsElement__ShapeType,
  &_swigt__p_SoShapeHintsElement__VertexOrdering,
  &_swigt__p_SoShapeKit,
  &_swigt__p_SoShapeStyleElement,
  &_swigt__p_SoShininessElement,
  &_swigt__p_SoShuttle,
  &_swigt__p_SoSimplifier,
  &_swigt__p_SoSimplifyAction,
  &_swigt__p_SoSoundElement,
  &_swigt__p_SoSpaceballButtonEvent,
  &_swigt__p_SoSpecularColorElement,
  &_swigt__p_SoSphere,
  &_swigt__p_SoSpotLight,
  &_swigt__p_SoSpotLightDragger,
  &_swigt__p_SoSpotLightManip,
  &_swigt__p_SoState,
  &_swigt__p_SoSurroundScale,
  &_swigt__p_SoSwitch,
  &_swigt__p_SoSwitchElement,
  &_swigt__p_SoTabBoxDragger,
  &_swigt__p_SoTabBoxManip,
  &_swigt__p_SoTabPlaneDragger,
  &_swigt__p_SoTempPath,
  &_swigt__p_SoText2,
  &_swigt__p_SoText3,
  &_swigt__p_SoTextDetail,
  &_swigt__p_SoTextOutlineEnabledElement,
  &_swigt__p_SoTexture,
  &_swigt__p_SoTexture2,
  &_swigt__p_SoTexture2Convert,
  &_swigt__p_SoTexture2Transform,
  &_swigt__p_SoTexture3,
  &_swigt__p_SoTexture3Transform,
  &_swigt__p_SoTextureCombine,
  &_swigt__p_SoTextureCombineElement,
  &_swigt__p_SoTextureCombineElement__Operand,
  &_swigt__p_SoTextureCombineElement__Operation,
  &_swigt__p_SoTextureCombineElement__Source,
  &_swigt__p_SoTextureCoordinate2,
  &_swigt__p_SoTextureCoordinate3,
  &_swigt__p_SoTextureCoordinateBinding,
  &_swigt__p_SoTextureCoordinateBindingElement,
  &_swigt__p_SoTextureCoordinateBundle,
  &_swigt__p_SoTextureCoordinateCache,
  &_swigt__p_SoTextureCoordinateCube,
  &_swigt__p_SoTextureCoordinateCylinder,
  &_swigt__p_SoTextureCoordinateDefault,
  &_swigt__p_SoTextureCoordinateEnvironment,
  &_swigt__p_SoTextureCoordinateFunction,
  &_swigt__p_SoTextureCoordinateNormalMap,
  &_swigt__p_SoTextureCoordinateObject,
  &_swigt__p_SoTextureCoordinatePlane,
  &_swigt__p_SoTextureCoordinateReflectionMap,
  &_swigt__p_SoTextureCoordinateSphere,
  &_swigt__p_SoTextureCubeMap,
  &_swigt__p_SoTextureMatrixTransform,
  &_swigt__p_SoTextureOverrideElement,
  &_swigt__p_SoTextureQualityElement,
  &_swigt__p_SoTextureScalePolicy,
  &_swigt__p_SoTextureUnit,
  &_swigt__p_SoTextureUnitElement,
  &_swigt__p_SoTimeCounter,
  &_swigt__p_SoTimerQueueSensor,
  &_swigt__p_SoTimerSensor,
  &_swigt__p_SoToVRML2Action,
  &_swigt__p_SoToVRMLAction,
  &_swigt__p_SoTrackballDragger,
  &_swigt__p_SoTrackballManip,
  &_swigt__p_SoTranReceiver,
  &_swigt__p_SoTranSender,
  &_swigt__p_SoTransform,
  &_swigt__p_SoTransformBoxDragger,
  &_swigt__p_SoTransformBoxManip,
  &_swigt__p_SoTransformManip,
  &_swigt__p_SoTransformSeparator,
  &_swigt__p_SoTransformVec3f,
  &_swigt__p_SoTransformation,
  &_swigt__p_SoTransformerDragger,
  &_swigt__p_SoTransformerManip,
  &_swigt__p_SoTranslate1Dragger,
  &_swigt__p_SoTranslate2Dragger,
  &_swigt__p_SoTranslation,
  &_swigt__p_SoTransparencyElement,
  &_swigt__p_SoTransparencyType,
  &_swigt__p_SoTriangleStripSet,
  &_swigt__p_SoTriggerAny,
  &_swigt__p_SoType,
  &_swigt__p_SoTypeList,
  &_swigt__p_SoUniformShaderParameter,
  &_swigt__p_SoUnits,
  &_swigt__p_SoUnitsElement,
  &_swigt__p_SoVBO,
  &_swigt__p_SoVRMLAnchor,
  &_swigt__p_SoVRMLAppearance,
  &_swigt__p_SoVRMLAudioClip,
  &_swigt__p_SoVRMLBackground,
  &_swigt__p_SoVRMLBillboard,
  &_swigt__p_SoVRMLBox,
  &_swigt__p_SoVRMLCollision,
  &_swigt__p_SoVRMLColor,
  &_swigt__p_SoVRMLColorInterpolator,
  &_swigt__p_SoVRMLCone,
  &_swigt__p_SoVRMLCoordinate,
  &_swigt__p_SoVRMLCoordinateInterpolator,
  &_swigt__p_SoVRMLCylinder,
  &_swigt__p_SoVRMLCylinderSensor,
  &_swigt__p_SoVRMLDirectionalLight,
  &_swigt__p_SoVRMLDragSensor,
  &_swigt__p_SoVRMLElevationGrid,
  &_swigt__p_SoVRMLExtrusion,
  &_swigt__p_SoVRMLFog,
  &_swigt__p_SoVRMLFontStyle,
  &_swigt__p_SoVRMLGeometry,
  &_swigt__p_SoVRMLGroup,
  &_swigt__p_SoVRMLImageTexture,
  &_swigt__p_SoVRMLIndexedFaceSet,
  &_swigt__p_SoVRMLIndexedLine,
  &_swigt__p_SoVRMLIndexedLineSet,
  &_swigt__p_SoVRMLIndexedShape,
  &_swigt__p_SoVRMLInline,
  &_swigt__p_SoVRMLInterpolator,
  &_swigt__p_SoVRMLLOD,
  &_swigt__p_SoVRMLLight,
  &_swigt__p_SoVRMLMaterial,
  &_swigt__p_SoVRMLMovieTexture,
  &_swigt__p_SoVRMLNavigationInfo,
  &_swigt__p_SoVRMLNormal,
  &_swigt__p_SoVRMLNormalInterpolator,
  &_swigt__p_SoVRMLOrientationInterpolator,
  &_swigt__p_SoVRMLParent,
  &_swigt__p_SoVRMLPixelTexture,
  &_swigt__p_SoVRMLPlaneSensor,
  &_swigt__p_SoVRMLPointLight,
  &_swigt__p_SoVRMLPointSet,
  &_swigt__p_SoVRMLPositionInterpolator,
  &_swigt__p_SoVRMLProximitySensor,
  &_swigt__p_SoVRMLScalarInterpolator,
  &_swigt__p_SoVRMLScript,
  &_swigt__p_SoVRMLSensor,
  &_swigt__p_SoVRMLShape,
  &_swigt__p_SoVRMLSound,
  &_swigt__p_SoVRMLSphere,
  &_swigt__p_SoVRMLSphereSensor,
  &_swigt__p_SoVRMLSpotLight,
  &_swigt__p_SoVRMLSwitch,
  &_swigt__p_SoVRMLText,
  &_swigt__p_SoVRMLTexture,
  &_swigt__p_SoVRMLTextureCoordinate,
  &_swigt__p_SoVRMLTextureTransform,
  &_swigt__p_SoVRMLTimeSensor,
  &_swigt__p_SoVRMLTouchSensor,
  &_swigt__p_SoVRMLTransform,
  &_swigt__p_SoVRMLVertexLine,
  &_swigt__p_SoVRMLVertexPoint,
  &_swigt__p_SoVRMLVertexShape,
  &_swigt__p_SoVRMLViewpoint,
  &_swigt__p_SoVRMLVisibilitySensor,
  &_swigt__p_SoVRMLWorldInfo,
  &_swigt__p_SoVectorOutput,
  &_swigt__p_SoVectorizeAction,
  &_swigt__p_SoVectorizePSAction,
  &_swigt__p_SoVertexAttribute,
  &_swigt__p_SoVertexAttributeBinding,
  &_swigt__p_SoVertexAttributeBindingElement,
  &_swigt__p_SoVertexAttributeData,
  &_swigt__p_SoVertexAttributeElement,
  &_swigt__p_SoVertexProperty,
  &_swigt__p_SoVertexShader,
  &_swigt__p_SoVertexShape,
  &_swigt__p_SoViewVolumeElement,
  &_swigt__p_SoViewingMatrixElement,
  &_swigt__p_SoViewportRegionElement,
  &_swigt__p_SoWWWAnchor,
  &_swigt__p_SoWWWInline,
  &_swigt__p_SoWindowElement,
  &_swigt__p_SoWrapperKit,
  &_swigt__p_SoWriteAction,
  &_swigt__p_a_2__double,
  &_swigt__p_a_2__doublep,
  &_swigt__p_a_2__int,
  &_swigt__p_a_2__intp,
  &_swigt__p_a_2__short,
  &_swigt__p_a_2__signed_char,
  &_swigt__p_a_3__int,
  &_swigt__p_a_3__intp,
  &_swigt__p_a_3__short,
  &_swigt__p_a_3__signed_char,
  &_swigt__p_a_4__a_4__double,
  &_swigt__p_a_4__a_4__doublep,
  &_swigt__p_a_4__a_4__float,
  &_swigt__p_a_4__a_4__floatp,
  &_swigt__p_a_4__double,
  &_swigt__p_a_4__doublep,
  &_swigt__p_a_4__float,
  &_swigt__p_a_4__floatp,
  &_swigt__p_a_4__int,
  &_swigt__p_a_4__intp,
  &_swigt__p_a_4__short,
  &_swigt__p_a_4__signed_char,
  &_swigt__p_a_4__unsigned_char,
  &_swigt__p_a_4__unsigned_int,
  &_swigt__p_a_4__unsigned_short,
  &_swigt__p_cc_glglue,
  &_swigt__p_cc_storage_f,
  &_swigt__p_cc_xml_doc,
  &_swigt__p_cc_xml_elt,
  &_swigt__p_char,
  &_swigt__p_charp,
  &_swigt__p_close_func,
  &_swigt__p_double,
  &_swigt__p_doublep,
  &_swigt__p_f_char__char,
  &_swigt__p_f_char__charp,
  &_swigt__p_f_float_p_void__int,
  &_swigt__p_f_float_p_void__intp,
  &_swigt__p_f_p_SoAction_p_SoNode__void,
  &_swigt__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto,
  &_swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int,
  &_swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp,
  &_swigt__p_f_p_q_const__SoError_p_void__void,
  &_swigt__p_f_p_void__SoGLRenderAction__AbortCode,
  &_swigt__p_f_p_void__float,
  &_swigt__p_f_p_void__floatp,
  &_swigt__p_f_p_void__int,
  &_swigt__p_f_p_void__intp,
  &_swigt__p_f_p_void__p_void,
  &_swigt__p_f_p_void__void,
  &_swigt__p_f_p_void_int__void,
  &_swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int,
  &_swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp,
  &_swigt__p_f_p_void_p_ScXMLStateMachine__void,
  &_swigt__p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void,
  &_swigt__p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void,
  &_swigt__p_f_p_void_p_SoAction__void,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp,
  &_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void,
  &_swigt__p_f_p_void_p_SoDragger__void,
  &_swigt__p_f_p_void_p_SoEventCallback__void,
  &_swigt__p_f_p_void_p_SoGLRenderAction__float,
  &_swigt__p_f_p_void_p_SoGLRenderAction__floatp,
  &_swigt__p_f_p_void_p_SoGLRenderAction__void,
  &_swigt__p_f_p_void_p_SoInput__void,
  &_swigt__p_f_p_void_p_SoPath__void,
  &_swigt__p_f_p_void_p_SoRenderManager__void,
  &_swigt__p_f_p_void_p_SoSceneManager__void,
  &_swigt__p_f_p_void_p_SoSelection__void,
  &_swigt__p_f_p_void_p_SoSensor__void,
  &_swigt__p_f_p_void_p_SoState_q_const__int__void,
  &_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__int,
  &_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__intp,
  &_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__long,
  &_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__longp,
  &_swigt__p_f_p_void_p_SoVRMLScript__void,
  &_swigt__p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp,
  &_swigt__p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response,
  &_swigt__p_f_p_void_p_q_const__SoPath__p_SoFullPath,
  &_swigt__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath,
  &_swigt__p_f_p_void_p_q_const__SoPath__p_SoPath,
  &_swigt__p_f_p_void_p_q_const__SoPath__p_SoTempPath,
  &_swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int,
  &_swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp,
  &_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath,
  &_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath,
  &_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoPath,
  &_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath,
  &_swigt__p_f_p_void_p_void__int,
  &_swigt__p_f_p_void_p_void__intp,
  &_swigt__p_f_p_void_p_void__void,
  &_swigt__p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t,
  &_swigt__p_f_p_void_p_void_p_void_p_void__void,
  &_swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f,
  &_swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f,
  &_swigt__p_f_p_void_size_t__p_void,
  &_swigt__p_f_p_void_unsigned_int__void,
  &_swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int,
  &_swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp,
  &_swigt__p_f_q_const__p_void_r_q_const__SbBox3f__int,
  &_swigt__p_f_q_const__p_void_r_q_const__SbBox3f__intp,
  &_swigt__p_f_q_const__p_void_r_q_const__SbSphere__int,
  &_swigt__p_f_q_const__p_void_r_q_const__SbSphere__intp,
  &_swigt__p_f_q_const__p_void_r_q_const__SbVec3f__int,
  &_swigt__p_f_q_const__p_void_r_q_const__SbVec3f__intp,
  &_swigt__p_f_q_const__unsigned_int__unsigned_int,
  &_swigt__p_f_r_q_const__SbName_float_int_p_void__int,
  &_swigt__p_f_r_q_const__SbName_float_int_p_void__intp,
  &_swigt__p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void,
  &_swigt__p_f_r_q_const__SbString_p_SbImage_p_void__int,
  &_swigt__p_f_r_q_const__SbString_p_SbImage_p_void__intp,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void,
  &_swigt__p_f_r_q_const__SbString_p_void_p_SoWWWInline__void,
  &_swigt__p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void,
  &_swigt__p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void,
  &_swigt__p_f_unsigned_int_p_void__void,
  &_swigt__p_f_unsigned_int_p_void_p_void__void,
  &_swigt__p_f_void__p_void,
  &_swigt__p_float,
  &_swigt__p_floatp,
  &_swigt__p_int,
  &_swigt__p_intp,
  &_swigt__p_long,
  &_swigt__p_long_long,
  &_swigt__p_longp,
  &_swigt__p_open_func,
  &_swigt__p_p_SbName,
  &_swigt__p_p_SbString,
  &_swigt__p_p_SbVec2f,
  &_swigt__p_p_ScXMLAddOpExprDataObj,
  &_swigt__p_p_ScXMLAndOpExprDataObj,
  &_swigt__p_p_ScXMLAppendOpExprDataObj,
  &_swigt__p_p_ScXMLBoolDataObj,
  &_swigt__p_p_ScXMLCoinAddOpExprDataObj,
  &_swigt__p_p_ScXMLCoinDivideOpExprDataObj,
  &_swigt__p_p_ScXMLCoinEqualsOpExprDataObj,
  &_swigt__p_p_ScXMLCoinLengthFuncExprDataObj,
  &_swigt__p_p_ScXMLCoinMultiplyOpExprDataObj,
  &_swigt__p_p_ScXMLCoinSubtractOpExprDataObj,
  &_swigt__p_p_ScXMLConstantDataObj,
  &_swigt__p_p_ScXMLDataObj,
  &_swigt__p_p_ScXMLDivideOpExprDataObj,
  &_swigt__p_p_ScXMLEqualsOpExprDataObj,
  &_swigt__p_p_ScXMLExprDataObj,
  &_swigt__p_p_ScXMLInExprDataObj,
  &_swigt__p_p_ScXMLMinimumExprDataObj,
  &_swigt__p_p_ScXMLMultiplyOpExprDataObj,
  &_swigt__p_p_ScXMLNegateOpExprDataObj,
  &_swigt__p_p_ScXMLNotOpExprDataObj,
  &_swigt__p_p_ScXMLOrOpExprDataObj,
  &_swigt__p_p_ScXMLRealDataObj,
  &_swigt__p_p_ScXMLReferenceDataObj,
  &_swigt__p_p_ScXMLSbDataObj,
  &_swigt__p_p_ScXMLStringDataObj,
  &_swigt__p_p_ScXMLSubtractOpExprDataObj,
  &_swigt__p_p_ScXMLXMLDataObj,
  &_swigt__p_p_SoAlphaTest,
  &_swigt__p_p_SoAnnotation,
  &_swigt__p_p_SoAntiSquish,
  &_swigt__p_p_SoAppearanceKit,
  &_swigt__p_p_SoArray,
  &_swigt__p_p_SoAsciiText,
  &_swigt__p_p_SoBase,
  &_swigt__p_p_SoBaseColor,
  &_swigt__p_p_SoBaseKit,
  &_swigt__p_p_SoBlinker,
  &_swigt__p_p_SoBoolOperation,
  &_swigt__p_p_SoBoxHighlightRenderAction,
  &_swigt__p_p_SoBumpMap,
  &_swigt__p_p_SoBumpMapCoordinate,
  &_swigt__p_p_SoBumpMapTransform,
  &_swigt__p_p_SoCacheHint,
  &_swigt__p_p_SoCalculator,
  &_swigt__p_p_SoCallback,
  &_swigt__p_p_SoCamera,
  &_swigt__p_p_SoCameraKit,
  &_swigt__p_p_SoCenterballDragger,
  &_swigt__p_p_SoCenterballManip,
  &_swigt__p_p_SoClipPlane,
  &_swigt__p_p_SoClipPlaneManip,
  &_swigt__p_p_SoColorIndex,
  &_swigt__p_p_SoComplexity,
  &_swigt__p_p_SoComposeMatrix,
  &_swigt__p_p_SoComposeRotation,
  &_swigt__p_p_SoComposeRotationFromTo,
  &_swigt__p_p_SoComposeVec2f,
  &_swigt__p_p_SoComposeVec3f,
  &_swigt__p_p_SoComposeVec4f,
  &_swigt__p_p_SoComputeBoundingBox,
  &_swigt__p_p_SoConcatenate,
  &_swigt__p_p_SoCone,
  &_swigt__p_p_SoCoordinate3,
  &_swigt__p_p_SoCoordinate4,
  &_swigt__p_p_SoCounter,
  &_swigt__p_p_SoCube,
  &_swigt__p_p_SoCylinder,
  &_swigt__p_p_SoDecomposeMatrix,
  &_swigt__p_p_SoDecomposeRotation,
  &_swigt__p_p_SoDecomposeVec2f,
  &_swigt__p_p_SoDecomposeVec3f,
  &_swigt__p_p_SoDecomposeVec4f,
  &_swigt__p_p_SoDepthBuffer,
  &_swigt__p_p_SoDirectionalLight,
  &_swigt__p_p_SoDirectionalLightDragger,
  &_swigt__p_p_SoDirectionalLightManip,
  &_swigt__p_p_SoDragPointDragger,
  &_swigt__p_p_SoDragger,
  &_swigt__p_p_SoDrawStyle,
  &_swigt__p_p_SoElapsedTime,
  &_swigt__p_p_SoEngine,
  &_swigt__p_p_SoEngineOutput,
  &_swigt__p_p_SoEnvironment,
  &_swigt__p_p_SoEventCallback,
  &_swigt__p_p_SoExtSelection,
  &_swigt__p_p_SoFaceSet,
  &_swigt__p_p_SoField,
  &_swigt__p_p_SoFieldContainer,
  &_swigt__p_p_SoFieldConverter,
  &_swigt__p_p_SoFile,
  &_swigt__p_p_SoFont,
  &_swigt__p_p_SoFontStyle,
  &_swigt__p_p_SoFragmentShader,
  &_swigt__p_p_SoFrustumCamera,
  &_swigt__p_p_SoFullPath,
  &_swigt__p_p_SoGLRenderAction,
  &_swigt__p_p_SoGate,
  &_swigt__p_p_SoGeoCoordinate,
  &_swigt__p_p_SoGeoLocation,
  &_swigt__p_p_SoGeoOrigin,
  &_swigt__p_p_SoGeoSeparator,
  &_swigt__p_p_SoGroup,
  &_swigt__p_p_SoHandleBoxDragger,
  &_swigt__p_p_SoHandleBoxManip,
  &_swigt__p_p_SoHeightMapToNormalMap,
  &_swigt__p_p_SoImage,
  &_swigt__p_p_SoIndexedFaceSet,
  &_swigt__p_p_SoIndexedLineSet,
  &_swigt__p_p_SoIndexedMarkerSet,
  &_swigt__p_p_SoIndexedNurbsCurve,
  &_swigt__p_p_SoIndexedNurbsSurface,
  &_swigt__p_p_SoIndexedPointSet,
  &_swigt__p_p_SoIndexedShape,
  &_swigt__p_p_SoIndexedTriangleStripSet,
  &_swigt__p_p_SoInfo,
  &_swigt__p_p_SoInteractionKit,
  &_swigt__p_p_SoInterpolate,
  &_swigt__p_p_SoInterpolateFloat,
  &_swigt__p_p_SoInterpolateRotation,
  &_swigt__p_p_SoInterpolateVec2f,
  &_swigt__p_p_SoInterpolateVec3f,
  &_swigt__p_p_SoInterpolateVec4f,
  &_swigt__p_p_SoJackDragger,
  &_swigt__p_p_SoJackManip,
  &_swigt__p_p_SoLOD,
  &_swigt__p_p_SoLabel,
  &_swigt__p_p_SoLevelOfDetail,
  &_swigt__p_p_SoLight,
  &_swigt__p_p_SoLightKit,
  &_swigt__p_p_SoLightModel,
  &_swigt__p_p_SoLineHighlightRenderAction,
  &_swigt__p_p_SoLineSet,
  &_swigt__p_p_SoLinearProfile,
  &_swigt__p_p_SoListener,
  &_swigt__p_p_SoLocateHighlight,
  &_swigt__p_p_SoMFBitMask,
  &_swigt__p_p_SoMFBool,
  &_swigt__p_p_SoMFColor,
  &_swigt__p_p_SoMFColorRGBA,
  &_swigt__p_p_SoMFDouble,
  &_swigt__p_p_SoMFEngine,
  &_swigt__p_p_SoMFEnum,
  &_swigt__p_p_SoMFFloat,
  &_swigt__p_p_SoMFInt32,
  &_swigt__p_p_SoMFMatrix,
  &_swigt__p_p_SoMFName,
  &_swigt__p_p_SoMFNode,
  &_swigt__p_p_SoMFPath,
  &_swigt__p_p_SoMFPlane,
  &_swigt__p_p_SoMFRotation,
  &_swigt__p_p_SoMFShort,
  &_swigt__p_p_SoMFString,
  &_swigt__p_p_SoMFTime,
  &_swigt__p_p_SoMFUInt32,
  &_swigt__p_p_SoMFUShort,
  &_swigt__p_p_SoMFVec2b,
  &_swigt__p_p_SoMFVec2d,
  &_swigt__p_p_SoMFVec2f,
  &_swigt__p_p_SoMFVec2i32,
  &_swigt__p_p_SoMFVec2s,
  &_swigt__p_p_SoMFVec3b,
  &_swigt__p_p_SoMFVec3d,
  &_swigt__p_p_SoMFVec3f,
  &_swigt__p_p_SoMFVec3i32,
  &_swigt__p_p_SoMFVec3s,
  &_swigt__p_p_SoMFVec4b,
  &_swigt__p_p_SoMFVec4d,
  &_swigt__p_p_SoMFVec4f,
  &_swigt__p_p_SoMFVec4i32,
  &_swigt__p_p_SoMFVec4s,
  &_swigt__p_p_SoMFVec4ub,
  &_swigt__p_p_SoMFVec4ui32,
  &_swigt__p_p_SoMFVec4us,
  &_swigt__p_p_SoMField,
  &_swigt__p_p_SoMarkerSet,
  &_swigt__p_p_SoMaterial,
  &_swigt__p_p_SoMaterialBinding,
  &_swigt__p_p_SoMatrixTransform,
  &_swigt__p_p_SoMultipleCopy,
  &_swigt__p_p_SoNode,
  &_swigt__p_p_SoNodeEngine,
  &_swigt__p_p_SoNodeKitListPart,
  &_swigt__p_p_SoNodeKitPath,
  &_swigt__p_p_SoNonIndexedShape,
  &_swigt__p_p_SoNormal,
  &_swigt__p_p_SoNormalBinding,
  &_swigt__p_p_SoNurbsCurve,
  &_swigt__p_p_SoNurbsProfile,
  &_swigt__p_p_SoNurbsSurface,
  &_swigt__p_p_SoOnOff,
  &_swigt__p_p_SoOneShot,
  &_swigt__p_p_SoOrthographicCamera,
  &_swigt__p_p_SoPackedColor,
  &_swigt__p_p_SoPath,
  &_swigt__p_p_SoPathSwitch,
  &_swigt__p_p_SoPendulum,
  &_swigt__p_p_SoPerspectiveCamera,
  &_swigt__p_p_SoPickStyle,
  &_swigt__p_p_SoPointLight,
  &_swigt__p_p_SoPointLightDragger,
  &_swigt__p_p_SoPointLightManip,
  &_swigt__p_p_SoPointSet,
  &_swigt__p_p_SoPolygonOffset,
  &_swigt__p_p_SoProfile,
  &_swigt__p_p_SoProfileCoordinate2,
  &_swigt__p_p_SoProfileCoordinate3,
  &_swigt__p_p_SoProto,
  &_swigt__p_p_SoProtoInstance,
  &_swigt__p_p_SoQuadMesh,
  &_swigt__p_p_SoResetTransform,
  &_swigt__p_p_SoReversePerspectiveCamera,
  &_swigt__p_p_SoRotateCylindricalDragger,
  &_swigt__p_p_SoRotateDiscDragger,
  &_swigt__p_p_SoRotateSphericalDragger,
  &_swigt__p_p_SoRotation,
  &_swigt__p_p_SoRotationXYZ,
  &_swigt__p_p_SoRotor,
  &_swigt__p_p_SoSFBitMask,
  &_swigt__p_p_SoSFBool,
  &_swigt__p_p_SoSFBox2d,
  &_swigt__p_p_SoSFBox2f,
  &_swigt__p_p_SoSFBox2i32,
  &_swigt__p_p_SoSFBox2s,
  &_swigt__p_p_SoSFBox3d,
  &_swigt__p_p_SoSFBox3f,
  &_swigt__p_p_SoSFBox3i32,
  &_swigt__p_p_SoSFBox3s,
  &_swigt__p_p_SoSFColor,
  &_swigt__p_p_SoSFColorRGBA,
  &_swigt__p_p_SoSFDouble,
  &_swigt__p_p_SoSFEngine,
  &_swigt__p_p_SoSFEnum,
  &_swigt__p_p_SoSFFloat,
  &_swigt__p_p_SoSFImage,
  &_swigt__p_p_SoSFImage3,
  &_swigt__p_p_SoSFInt32,
  &_swigt__p_p_SoSFMatrix,
  &_swigt__p_p_SoSFName,
  &_swigt__p_p_SoSFNode,
  &_swigt__p_p_SoSFPath,
  &_swigt__p_p_SoSFPlane,
  &_swigt__p_p_SoSFRotation,
  &_swigt__p_p_SoSFShort,
  &_swigt__p_p_SoSFString,
  &_swigt__p_p_SoSFTime,
  &_swigt__p_p_SoSFTrigger,
  &_swigt__p_p_SoSFUInt32,
  &_swigt__p_p_SoSFUShort,
  &_swigt__p_p_SoSFVec2b,
  &_swigt__p_p_SoSFVec2d,
  &_swigt__p_p_SoSFVec2f,
  &_swigt__p_p_SoSFVec2i32,
  &_swigt__p_p_SoSFVec2s,
  &_swigt__p_p_SoSFVec3b,
  &_swigt__p_p_SoSFVec3d,
  &_swigt__p_p_SoSFVec3f,
  &_swigt__p_p_SoSFVec3i32,
  &_swigt__p_p_SoSFVec3s,
  &_swigt__p_p_SoSFVec4b,
  &_swigt__p_p_SoSFVec4d,
  &_swigt__p_p_SoSFVec4f,
  &_swigt__p_p_SoSFVec4i32,
  &_swigt__p_p_SoSFVec4s,
  &_swigt__p_p_SoSFVec4ub,
  &_swigt__p_p_SoSFVec4ui32,
  &_swigt__p_p_SoSFVec4us,
  &_swigt__p_p_SoSField,
  &_swigt__p_p_SoScale,
  &_swigt__p_p_SoScale1Dragger,
  &_swigt__p_p_SoScale2Dragger,
  &_swigt__p_p_SoScale2UniformDragger,
  &_swigt__p_p_SoScaleUniformDragger,
  &_swigt__p_p_SoSceneKit,
  &_swigt__p_p_SoSceneTexture2,
  &_swigt__p_p_SoSceneTextureCubeMap,
  &_swigt__p_p_SoSelectOne,
  &_swigt__p_p_SoSelection,
  &_swigt__p_p_SoSeparator,
  &_swigt__p_p_SoSeparatorKit,
  &_swigt__p_p_SoShaderObject,
  &_swigt__p_p_SoShaderParameter,
  &_swigt__p_p_SoShaderParameter1f,
  &_swigt__p_p_SoShaderParameter1i,
  &_swigt__p_p_SoShaderParameter2f,
  &_swigt__p_p_SoShaderParameter2i,
  &_swigt__p_p_SoShaderParameter3f,
  &_swigt__p_p_SoShaderParameter3i,
  &_swigt__p_p_SoShaderParameter4f,
  &_swigt__p_p_SoShaderParameter4i,
  &_swigt__p_p_SoShaderParameterArray1f,
  &_swigt__p_p_SoShaderParameterArray1i,
  &_swigt__p_p_SoShaderParameterArray2f,
  &_swigt__p_p_SoShaderParameterArray2i,
  &_swigt__p_p_SoShaderParameterArray3f,
  &_swigt__p_p_SoShaderParameterArray3i,
  &_swigt__p_p_SoShaderParameterArray4f,
  &_swigt__p_p_SoShaderParameterArray4i,
  &_swigt__p_p_SoShaderParameterMatrix,
  &_swigt__p_p_SoShaderParameterMatrixArray,
  &_swigt__p_p_SoShaderProgram,
  &_swigt__p_p_SoShaderStateMatrixParameter,
  &_swigt__p_p_SoShape,
  &_swigt__p_p_SoShapeHints,
  &_swigt__p_p_SoShapeKit,
  &_swigt__p_p_SoShuttle,
  &_swigt__p_p_SoSphere,
  &_swigt__p_p_SoSpotLight,
  &_swigt__p_p_SoSpotLightDragger,
  &_swigt__p_p_SoSpotLightManip,
  &_swigt__p_p_SoSurroundScale,
  &_swigt__p_p_SoSwitch,
  &_swigt__p_p_SoTabBoxDragger,
  &_swigt__p_p_SoTabBoxManip,
  &_swigt__p_p_SoTabPlaneDragger,
  &_swigt__p_p_SoTempPath,
  &_swigt__p_p_SoText2,
  &_swigt__p_p_SoText3,
  &_swigt__p_p_SoTexture,
  &_swigt__p_p_SoTexture2,
  &_swigt__p_p_SoTexture2Convert,
  &_swigt__p_p_SoTexture2Transform,
  &_swigt__p_p_SoTexture3,
  &_swigt__p_p_SoTexture3Transform,
  &_swigt__p_p_SoTextureCombine,
  &_swigt__p_p_SoTextureCoordinate2,
  &_swigt__p_p_SoTextureCoordinate3,
  &_swigt__p_p_SoTextureCoordinateBinding,
  &_swigt__p_p_SoTextureCoordinateCube,
  &_swigt__p_p_SoTextureCoordinateCylinder,
  &_swigt__p_p_SoTextureCoordinateDefault,
  &_swigt__p_p_SoTextureCoordinateEnvironment,
  &_swigt__p_p_SoTextureCoordinateFunction,
  &_swigt__p_p_SoTextureCoordinateNormalMap,
  &_swigt__p_p_SoTextureCoordinateObject,
  &_swigt__p_p_SoTextureCoordinatePlane,
  &_swigt__p_p_SoTextureCoordinateReflectionMap,
  &_swigt__p_p_SoTextureCoordinateSphere,
  &_swigt__p_p_SoTextureCubeMap,
  &_swigt__p_p_SoTextureMatrixTransform,
  &_swigt__p_p_SoTextureScalePolicy,
  &_swigt__p_p_SoTextureUnit,
  &_swigt__p_p_SoTimeCounter,
  &_swigt__p_p_SoTrackballDragger,
  &_swigt__p_p_SoTrackballManip,
  &_swigt__p_p_SoTransform,
  &_swigt__p_p_SoTransformBoxDragger,
  &_swigt__p_p_SoTransformBoxManip,
  &_swigt__p_p_SoTransformManip,
  &_swigt__p_p_SoTransformSeparator,
  &_swigt__p_p_SoTransformVec3f,
  &_swigt__p_p_SoTransformation,
  &_swigt__p_p_SoTransformerDragger,
  &_swigt__p_p_SoTransformerManip,
  &_swigt__p_p_SoTranslate1Dragger,
  &_swigt__p_p_SoTranslate2Dragger,
  &_swigt__p_p_SoTranslation,
  &_swigt__p_p_SoTransparencyType,
  &_swigt__p_p_SoTriangleStripSet,
  &_swigt__p_p_SoTriggerAny,
  &_swigt__p_p_SoUniformShaderParameter,
  &_swigt__p_p_SoUnits,
  &_swigt__p_p_SoVRMLAnchor,
  &_swigt__p_p_SoVRMLAppearance,
  &_swigt__p_p_SoVRMLAudioClip,
  &_swigt__p_p_SoVRMLBackground,
  &_swigt__p_p_SoVRMLBillboard,
  &_swigt__p_p_SoVRMLBox,
  &_swigt__p_p_SoVRMLCollision,
  &_swigt__p_p_SoVRMLColor,
  &_swigt__p_p_SoVRMLColorInterpolator,
  &_swigt__p_p_SoVRMLCone,
  &_swigt__p_p_SoVRMLCoordinate,
  &_swigt__p_p_SoVRMLCoordinateInterpolator,
  &_swigt__p_p_SoVRMLCylinder,
  &_swigt__p_p_SoVRMLCylinderSensor,
  &_swigt__p_p_SoVRMLDirectionalLight,
  &_swigt__p_p_SoVRMLDragSensor,
  &_swigt__p_p_SoVRMLElevationGrid,
  &_swigt__p_p_SoVRMLExtrusion,
  &_swigt__p_p_SoVRMLFog,
  &_swigt__p_p_SoVRMLFontStyle,
  &_swigt__p_p_SoVRMLGeometry,
  &_swigt__p_p_SoVRMLGroup,
  &_swigt__p_p_SoVRMLImageTexture,
  &_swigt__p_p_SoVRMLIndexedFaceSet,
  &_swigt__p_p_SoVRMLIndexedLine,
  &_swigt__p_p_SoVRMLIndexedLineSet,
  &_swigt__p_p_SoVRMLIndexedShape,
  &_swigt__p_p_SoVRMLInline,
  &_swigt__p_p_SoVRMLInterpolator,
  &_swigt__p_p_SoVRMLLOD,
  &_swigt__p_p_SoVRMLLight,
  &_swigt__p_p_SoVRMLMaterial,
  &_swigt__p_p_SoVRMLMovieTexture,
  &_swigt__p_p_SoVRMLNavigationInfo,
  &_swigt__p_p_SoVRMLNormal,
  &_swigt__p_p_SoVRMLNormalInterpolator,
  &_swigt__p_p_SoVRMLOrientationInterpolator,
  &_swigt__p_p_SoVRMLParent,
  &_swigt__p_p_SoVRMLPixelTexture,
  &_swigt__p_p_SoVRMLPlaneSensor,
  &_swigt__p_p_SoVRMLPointLight,
  &_swigt__p_p_SoVRMLPointSet,
  &_swigt__p_p_SoVRMLPositionInterpolator,
  &_swigt__p_p_SoVRMLProximitySensor,
  &_swigt__p_p_SoVRMLScalarInterpolator,
  &_swigt__p_p_SoVRMLScript,
  &_swigt__p_p_SoVRMLSensor,
  &_swigt__p_p_SoVRMLShape,
  &_swigt__p_p_SoVRMLSound,
  &_swigt__p_p_SoVRMLSphere,
  &_swigt__p_p_SoVRMLSphereSensor,
  &_swigt__p_p_SoVRMLSpotLight,
  &_swigt__p_p_SoVRMLSwitch,
  &_swigt__p_p_SoVRMLText,
  &_swigt__p_p_SoVRMLTexture,
  &_swigt__p_p_SoVRMLTextureCoordinate,
  &_swigt__p_p_SoVRMLTextureTransform,
  &_swigt__p_p_SoVRMLTimeSensor,
  &_swigt__p_p_SoVRMLTouchSensor,
  &_swigt__p_p_SoVRMLTransform,
  &_swigt__p_p_SoVRMLVertexLine,
  &_swigt__p_p_SoVRMLVertexPoint,
  &_swigt__p_p_SoVRMLVertexShape,
  &_swigt__p_p_SoVRMLViewpoint,
  &_swigt__p_p_SoVRMLVisibilitySensor,
  &_swigt__p_p_SoVRMLWorldInfo,
  &_swigt__p_p_SoVertexAttribute,
  &_swigt__p_p_SoVertexAttributeBinding,
  &_swigt__p_p_SoVertexProperty,
  &_swigt__p_p_SoVertexShader,
  &_swigt__p_p_SoVertexShape,
  &_swigt__p_p_SoWWWAnchor,
  &_swigt__p_p_SoWWWInline,
  &_swigt__p_p_SoWrapperKit,
  &_swigt__p_p_char,
  &_swigt__p_p_charp,
  &_swigt__p_p_f_p_SoAction_p_SoNode__void,
  &_swigt__p_p_f_p_void__SoGLRenderAction__AbortCode,
  &_swigt__p_p_f_p_void_p_SoInput__void,
  &_swigt__p_p_float,
  &_swigt__p_p_floatp,
  &_swigt__p_p_int,
  &_swigt__p_p_intp,
  &_swigt__p_p_unsigned_char,
  &_swigt__p_p_void,
  &_swigt__p_read_func,
  &_swigt__p_seek_func,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_size_t,
  &_swigt__p_std__FILE,
  &_swigt__p_tell_func,
  &_swigt__p_time_t,
  &_swigt__p_timeval,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_void,
  &_swigt__p_wchar_t,
};

static swig_cast_info _swigc__p_AttributeApplyFunc[] = {  {&_swigt__p_AttributeApplyFunc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContextDestructionCB[] = {  {&_swigt__p_ContextDestructionCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Key[] = {  {&_swigt__p_Key, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProgressCallbackType[] = {  {&_swigt__p_ProgressCallbackType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBSPTree[] = {  {&_swigt__p_SbBSPTree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBarrier[] = {  {&_swigt__p_SbBarrier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox2d[] = {  {&_swigt__p_SbBox2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox2f[] = {  {&_swigt__p_SbBox2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox2i32[] = {  {&_swigt__p_SbBox2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox2s[] = {  {&_swigt__p_SbBox2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox3d[] = {  {&_swigt__p_SbBox3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox3f[] = {  {&_swigt__p_SbBox3f, 0, 0, 0},  {&_swigt__p_SbXfBox3f, _p_SbXfBox3fTo_p_SbBox3f, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox3i32[] = {  {&_swigt__p_SbBox3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbBox3s[] = {  {&_swigt__p_SbBox3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbByteBuffer[] = {  {&_swigt__p_SbByteBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbClip[] = {  {&_swigt__p_SbClip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbColor[] = {  {&_swigt__p_SbColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbColor4f[] = {  {&_swigt__p_SbColor4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCondVar[] = {  {&_swigt__p_SbCondVar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCylinder[] = {  {&_swigt__p_SbCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCylinderPlaneProjector[] = {  {&_swigt__p_SbCylinderPlaneProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCylinderProjector[] = {  {&_swigt__p_SbCylinderProjector, 0, 0, 0},  {&_swigt__p_SbCylinderPlaneProjector, _p_SbCylinderPlaneProjectorTo_p_SbCylinderProjector, 0, 0},  {&_swigt__p_SbCylinderSectionProjector, _p_SbCylinderSectionProjectorTo_p_SbCylinderProjector, 0, 0},  {&_swigt__p_SbCylinderSheetProjector, _p_SbCylinderSheetProjectorTo_p_SbCylinderProjector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCylinderSectionProjector[] = {  {&_swigt__p_SbCylinderSectionProjector, 0, 0, 0},  {&_swigt__p_SbCylinderPlaneProjector, _p_SbCylinderPlaneProjectorTo_p_SbCylinderSectionProjector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbCylinderSheetProjector[] = {  {&_swigt__p_SbCylinderSheetProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDPLine[] = {  {&_swigt__p_SbDPLine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDPMatrix[] = {  {&_swigt__p_SbDPMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDPPlane[] = {  {&_swigt__p_SbDPPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDPRotation[] = {  {&_swigt__p_SbDPRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDPViewVolume[] = {  {&_swigt__p_SbDPViewVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbDict[] = {  {&_swigt__p_SbDict, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbFifo[] = {  {&_swigt__p_SbFifo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbHeap[] = {  {&_swigt__p_SbHeap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbHeapFuncs[] = {  {&_swigt__p_SbHeapFuncs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbImage[] = {  {&_swigt__p_SbImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbIntList[] = {  {&_swigt__p_SbIntList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbLine[] = {  {&_swigt__p_SbLine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbLineProjector[] = {  {&_swigt__p_SbLineProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbListT_SbString_t[] = {  {&_swigt__p_SbListT_SbString_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbListT_char_const_p_t[] = {  {&_swigt__p_SbListT_char_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbListT_int_t[] = {  {&_swigt__p_SbListT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbListT_void_p_t[] = {  {&_swigt__p_SbListT_void_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbMatrix[] = {  {&_swigt__p_SbMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbMutex[] = {  {&_swigt__p_SbMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbName[] = {  {&_swigt__p_SbName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbOctTree[] = {  {&_swigt__p_SbOctTree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbOctTreeFuncs[] = {  {&_swigt__p_SbOctTreeFuncs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbPList[] = {  {&_swigt__p_SbPList, 0, 0, 0},  {&_swigt__p_SbIntList, _p_SbIntListTo_p_SbPList, 0, 0},  {&_swigt__p_SbStringList, _p_SbStringListTo_p_SbPList, 0, 0},  {&_swigt__p_SbVec3fList, _p_SbVec3fListTo_p_SbPList, 0, 0},  {&_swigt__p_SoActionMethodList, _p_SoActionMethodListTo_p_SbPList, 0, 0},  {&_swigt__p_SoAuditorList, _p_SoAuditorListTo_p_SbPList, 0, 0},  {&_swigt__p_SoBaseList, _p_SoBaseListTo_p_SbPList, 0, 0},  {&_swigt__p_SoChildList, _p_SoChildListTo_p_SbPList, 0, 0},  {&_swigt__p_SoDetailList, _p_SoDetailListTo_p_SbPList, 0, 0},  {&_swigt__p_SoEngineList, _p_SoEngineListTo_p_SbPList, 0, 0},  {&_swigt__p_SoEngineOutputList, _p_SoEngineOutputListTo_p_SbPList, 0, 0},  {&_swigt__p_SoFieldList, _p_SoFieldListTo_p_SbPList, 0, 0},  {&_swigt__p_SoNodeList, _p_SoNodeListTo_p_SbPList, 0, 0},  {&_swigt__p_SoPathList, _p_SoPathListTo_p_SbPList, 0, 0},  {&_swigt__p_SoPickedPointList, _p_SoPickedPointListTo_p_SbPList, 0, 0},  {&_swigt__p_SoTypeList, _p_SoTypeListTo_p_SbPList, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbPlane[] = {  {&_swigt__p_SbPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbPlaneProjector[] = {  {&_swigt__p_SbPlaneProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbProjector[] = {  {&_swigt__p_SbProjector, 0, 0, 0},  {&_swigt__p_SbCylinderPlaneProjector, _p_SbCylinderPlaneProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbCylinderProjector, _p_SbCylinderProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbCylinderSectionProjector, _p_SbCylinderSectionProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbCylinderSheetProjector, _p_SbCylinderSheetProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbLineProjector, _p_SbLineProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbPlaneProjector, _p_SbPlaneProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbSpherePlaneProjector, _p_SbSpherePlaneProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbSphereProjector, _p_SbSphereProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbSphereSectionProjector, _p_SbSphereSectionProjectorTo_p_SbProjector, 0, 0},  {&_swigt__p_SbSphereSheetProjector, _p_SbSphereSheetProjectorTo_p_SbProjector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbRWMutex[] = {  {&_swigt__p_SbRWMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbRotation[] = {  {&_swigt__p_SbRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbSphere[] = {  {&_swigt__p_SbSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbSpherePlaneProjector[] = {  {&_swigt__p_SbSpherePlaneProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbSphereProjector[] = {  {&_swigt__p_SbSphereProjector, 0, 0, 0},  {&_swigt__p_SbSpherePlaneProjector, _p_SbSpherePlaneProjectorTo_p_SbSphereProjector, 0, 0},  {&_swigt__p_SbSphereSectionProjector, _p_SbSphereSectionProjectorTo_p_SbSphereProjector, 0, 0},  {&_swigt__p_SbSphereSheetProjector, _p_SbSphereSheetProjectorTo_p_SbSphereProjector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbSphereSectionProjector[] = {  {&_swigt__p_SbSphereSectionProjector, 0, 0, 0},  {&_swigt__p_SbSpherePlaneProjector, _p_SbSpherePlaneProjectorTo_p_SbSphereSectionProjector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbSphereSheetProjector[] = {  {&_swigt__p_SbSphereSheetProjector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbStorage[] = {  {&_swigt__p_SbStorage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbString[] = {  {&_swigt__p_SbString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbStringList[] = {  {&_swigt__p_SbStringList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbTesselator[] = {  {&_swigt__p_SbTesselator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbThread[] = {  {&_swigt__p_SbThread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbThreadAutoLock[] = {  {&_swigt__p_SbThreadAutoLock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbThreadMutex[] = {  {&_swigt__p_SbThreadMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbTime[] = {  {&_swigt__p_SbTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2b[] = {  {&_swigt__p_SbVec2b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2d[] = {  {&_swigt__p_SbVec2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2f[] = {  {&_swigt__p_SbVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2i32[] = {  {&_swigt__p_SbVec2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2s[] = {  {&_swigt__p_SbVec2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2ub[] = {  {&_swigt__p_SbVec2ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2ui32[] = {  {&_swigt__p_SbVec2ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec2us[] = {  {&_swigt__p_SbVec2us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3b[] = {  {&_swigt__p_SbVec3b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3d[] = {  {&_swigt__p_SbVec3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3f[] = {  {&_swigt__p_SbVec3f, 0, 0, 0},  {&_swigt__p_SbColor, _p_SbColorTo_p_SbVec3f, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3fList[] = {  {&_swigt__p_SbVec3fList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3i32[] = {  {&_swigt__p_SbVec3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3s[] = {  {&_swigt__p_SbVec3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3ub[] = {  {&_swigt__p_SbVec3ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3ui32[] = {  {&_swigt__p_SbVec3ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec3us[] = {  {&_swigt__p_SbVec3us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4b[] = {  {&_swigt__p_SbVec4b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4d[] = {  {&_swigt__p_SbVec4d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4f[] = {  {&_swigt__p_SbVec4f, 0, 0, 0},  {&_swigt__p_SbColor4f, _p_SbColor4fTo_p_SbVec4f, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4i32[] = {  {&_swigt__p_SbVec4i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4s[] = {  {&_swigt__p_SbVec4s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4ub[] = {  {&_swigt__p_SbVec4ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4ui32[] = {  {&_swigt__p_SbVec4ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbVec4us[] = {  {&_swigt__p_SbVec4us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbViewVolume[] = {  {&_swigt__p_SbViewVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbViewportRegion[] = {  {&_swigt__p_SbViewportRegion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SbXfBox3f[] = {  {&_swigt__p_SbXfBox3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXML[] = {  {&_swigt__p_ScXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAbstractStateElt[] = {  {&_swigt__p_ScXMLAbstractStateElt, 0, 0, 0},  {&_swigt__p_ScXMLFinalElt, _p_ScXMLFinalEltTo_p_ScXMLAbstractStateElt, 0, 0},  {&_swigt__p_ScXMLParallelElt, _p_ScXMLParallelEltTo_p_ScXMLAbstractStateElt, 0, 0},  {&_swigt__p_ScXMLStateElt, _p_ScXMLStateEltTo_p_ScXMLAbstractStateElt, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAddOpExprDataObj[] = {  {&_swigt__p_ScXMLAddOpExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLCoinAddOpExprDataObj, _p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLAddOpExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAnchorElt[] = {  {&_swigt__p_ScXMLAnchorElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAndOpExprDataObj[] = {  {&_swigt__p_ScXMLAndOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAppendOpExprDataObj[] = {  {&_swigt__p_ScXMLAppendOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLAssignElt[] = {  {&_swigt__p_ScXMLAssignElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLBoolDataObj[] = {  {&_swigt__p_ScXMLBoolDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinAddOpExprDataObj[] = {  {&_swigt__p_ScXMLCoinAddOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinDivideOpExprDataObj[] = {  {&_swigt__p_ScXMLCoinDivideOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinEqualsOpExprDataObj[] = {  {&_swigt__p_ScXMLCoinEqualsOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinEvaluator[] = {  {&_swigt__p_ScXMLCoinEvaluator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinLengthFuncExprDataObj[] = {  {&_swigt__p_ScXMLCoinLengthFuncExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinMultiplyOpExprDataObj[] = {  {&_swigt__p_ScXMLCoinMultiplyOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLCoinSubtractOpExprDataObj[] = {  {&_swigt__p_ScXMLCoinSubtractOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLConstantDataObj[] = {  {&_swigt__p_ScXMLConstantDataObj, 0, 0, 0},  {&_swigt__p_ScXMLBoolDataObj, _p_ScXMLBoolDataObjTo_p_ScXMLConstantDataObj, 0, 0},  {&_swigt__p_ScXMLRealDataObj, _p_ScXMLRealDataObjTo_p_ScXMLConstantDataObj, 0, 0},  {&_swigt__p_ScXMLSbDataObj, _p_ScXMLSbDataObjTo_p_ScXMLConstantDataObj, 0, 0},  {&_swigt__p_ScXMLStringDataObj, _p_ScXMLStringDataObjTo_p_ScXMLConstantDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLContentElt[] = {  {&_swigt__p_ScXMLContentElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLDataElt[] = {  {&_swigt__p_ScXMLDataElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLDataModelElt[] = {  {&_swigt__p_ScXMLDataModelElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLDataObj[] = {  {&_swigt__p_ScXMLDataObj, 0, 0, 0},  {&_swigt__p_ScXMLAddOpExprDataObj, _p_ScXMLAddOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLAndOpExprDataObj, _p_ScXMLAndOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLAppendOpExprDataObj, _p_ScXMLAppendOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLBoolDataObj, _p_ScXMLBoolDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinAddOpExprDataObj, _p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinDivideOpExprDataObj, _p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinEqualsOpExprDataObj, _p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinLengthFuncExprDataObj, _p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinMultiplyOpExprDataObj, _p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLCoinSubtractOpExprDataObj, _p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLConstantDataObj, _p_ScXMLConstantDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLDivideOpExprDataObj, _p_ScXMLDivideOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLEqualsOpExprDataObj, _p_ScXMLEqualsOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLExprDataObj, _p_ScXMLExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLInExprDataObj, _p_ScXMLInExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLMinimumExprDataObj, _p_ScXMLMinimumExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLMultiplyOpExprDataObj, _p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLNegateOpExprDataObj, _p_ScXMLNegateOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLNotOpExprDataObj, _p_ScXMLNotOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLOrOpExprDataObj, _p_ScXMLOrOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLRealDataObj, _p_ScXMLRealDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLReferenceDataObj, _p_ScXMLReferenceDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLSbDataObj, _p_ScXMLSbDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLStringDataObj, _p_ScXMLStringDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLSubtractOpExprDataObj, _p_ScXMLSubtractOpExprDataObjTo_p_ScXMLDataObj, 0, 0},  {&_swigt__p_ScXMLXMLDataObj, _p_ScXMLXMLDataObjTo_p_ScXMLDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLDivideOpExprDataObj[] = {  {&_swigt__p_ScXMLDivideOpExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLCoinDivideOpExprDataObj, _p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLDivideOpExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLDocument[] = {  {&_swigt__p_ScXMLDocument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLECMAScriptEvaluator[] = {  {&_swigt__p_ScXMLECMAScriptEvaluator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLElseElt[] = {  {&_swigt__p_ScXMLElseElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLElseIfElt[] = {  {&_swigt__p_ScXMLElseIfElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLElt[] = {  {&_swigt__p_ScXMLElt, 0, 0, 0},  {&_swigt__p_ScXMLAbstractStateElt, _p_ScXMLAbstractStateEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLAnchorElt, _p_ScXMLAnchorEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLAssignElt, _p_ScXMLAssignEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLContentElt, _p_ScXMLContentEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLDataElt, _p_ScXMLDataEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLDataModelElt, _p_ScXMLDataModelEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLElseElt, _p_ScXMLElseEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLElseIfElt, _p_ScXMLElseIfEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLEventElt, _p_ScXMLEventEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLExecutableElt, _p_ScXMLExecutableEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLFinalElt, _p_ScXMLFinalEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLFinalizeElt, _p_ScXMLFinalizeEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLHistoryElt, _p_ScXMLHistoryEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLIfElt, _p_ScXMLIfEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLInitialElt, _p_ScXMLInitialEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLInvokeElt, _p_ScXMLInvokeEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLLogElt, _p_ScXMLLogEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLOnEntryElt, _p_ScXMLOnEntryEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLOnExitElt, _p_ScXMLOnExitEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLParallelElt, _p_ScXMLParallelEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLParamElt, _p_ScXMLParamEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLScriptElt, _p_ScXMLScriptEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLScxmlElt, _p_ScXMLScxmlEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLSendElt, _p_ScXMLSendEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLStateElt, _p_ScXMLStateEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLTransitionElt, _p_ScXMLTransitionEltTo_p_ScXMLElt, 0, 0},  {&_swigt__p_ScXMLValidateElt, _p_ScXMLValidateEltTo_p_ScXMLElt, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEltReader[] = {  {&_swigt__p_ScXMLEltReader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEqualsOpExprDataObj[] = {  {&_swigt__p_ScXMLEqualsOpExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLCoinEqualsOpExprDataObj, _p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLEqualsOpExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEvaluator[] = {  {&_swigt__p_ScXMLEvaluator, 0, 0, 0},  {&_swigt__p_ScXMLCoinEvaluator, _p_ScXMLCoinEvaluatorTo_p_ScXMLEvaluator, 0, 0},  {&_swigt__p_ScXMLECMAScriptEvaluator, _p_ScXMLECMAScriptEvaluatorTo_p_ScXMLEvaluator, 0, 0},  {&_swigt__p_ScXMLMinimumEvaluator, _p_ScXMLMinimumEvaluatorTo_p_ScXMLEvaluator, 0, 0},  {&_swigt__p_ScXMLXPathEvaluator, _p_ScXMLXPathEvaluatorTo_p_ScXMLEvaluator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEvent[] = {  {&_swigt__p_ScXMLEvent, 0, 0, 0},  {&_swigt__p_SoScXMLEvent, _p_SoScXMLEventTo_p_ScXMLEvent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEventElt[] = {  {&_swigt__p_ScXMLEventElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLEventTarget[] = {  {&_swigt__p_ScXMLEventTarget, 0, 0, 0},  {&_swigt__p_ScXMLStateMachine, _p_ScXMLStateMachineTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLDollyTarget, _p_SoScXMLDollyTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLFlightControlTarget, _p_SoScXMLFlightControlTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLMiscTarget, _p_SoScXMLMiscTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLMotionTarget, _p_SoScXMLMotionTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLNavigationTarget, _p_SoScXMLNavigationTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLPanTarget, _p_SoScXMLPanTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLRotateTarget, _p_SoScXMLRotateTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLSeekTarget, _p_SoScXMLSeekTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLSpinTarget, _p_SoScXMLSpinTargetTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLStateMachine, _p_SoScXMLStateMachineTo_p_ScXMLEventTarget, 0, 0},  {&_swigt__p_SoScXMLZoomTarget, _p_SoScXMLZoomTargetTo_p_ScXMLEventTarget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLExecutableElt[] = {  {&_swigt__p_ScXMLExecutableElt, 0, 0, 0},  {&_swigt__p_ScXMLAssignElt, _p_ScXMLAssignEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLElseElt, _p_ScXMLElseEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLElseIfElt, _p_ScXMLElseIfEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLEventElt, _p_ScXMLEventEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLIfElt, _p_ScXMLIfEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLInvokeElt, _p_ScXMLInvokeEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLLogElt, _p_ScXMLLogEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLScriptElt, _p_ScXMLScriptEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLSendElt, _p_ScXMLSendEltTo_p_ScXMLExecutableElt, 0, 0},  {&_swigt__p_ScXMLValidateElt, _p_ScXMLValidateEltTo_p_ScXMLExecutableElt, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLExprDataObj[] = {  {&_swigt__p_ScXMLExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLAddOpExprDataObj, _p_ScXMLAddOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLAndOpExprDataObj, _p_ScXMLAndOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLAppendOpExprDataObj, _p_ScXMLAppendOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinAddOpExprDataObj, _p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinDivideOpExprDataObj, _p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinEqualsOpExprDataObj, _p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinLengthFuncExprDataObj, _p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinMultiplyOpExprDataObj, _p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLCoinSubtractOpExprDataObj, _p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLDivideOpExprDataObj, _p_ScXMLDivideOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLEqualsOpExprDataObj, _p_ScXMLEqualsOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLInExprDataObj, _p_ScXMLInExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLMinimumExprDataObj, _p_ScXMLMinimumExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLMultiplyOpExprDataObj, _p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLNegateOpExprDataObj, _p_ScXMLNegateOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLNotOpExprDataObj, _p_ScXMLNotOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLOrOpExprDataObj, _p_ScXMLOrOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLReferenceDataObj, _p_ScXMLReferenceDataObjTo_p_ScXMLExprDataObj, 0, 0},  {&_swigt__p_ScXMLSubtractOpExprDataObj, _p_ScXMLSubtractOpExprDataObjTo_p_ScXMLExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLFinalElt[] = {  {&_swigt__p_ScXMLFinalElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLFinalizeElt[] = {  {&_swigt__p_ScXMLFinalizeElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLHistoryElt[] = {  {&_swigt__p_ScXMLHistoryElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLIfElt[] = {  {&_swigt__p_ScXMLIfElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLInExprDataObj[] = {  {&_swigt__p_ScXMLInExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLInitialElt[] = {  {&_swigt__p_ScXMLInitialElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLInvokeElt[] = {  {&_swigt__p_ScXMLInvokeElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLLogElt[] = {  {&_swigt__p_ScXMLLogElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLMinimumEvaluator[] = {  {&_swigt__p_ScXMLMinimumEvaluator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLMinimumExprDataObj[] = {  {&_swigt__p_ScXMLMinimumExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLInExprDataObj, _p_ScXMLInExprDataObjTo_p_ScXMLMinimumExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLMultiplyOpExprDataObj[] = {  {&_swigt__p_ScXMLMultiplyOpExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLCoinMultiplyOpExprDataObj, _p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLMultiplyOpExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLNegateOpExprDataObj[] = {  {&_swigt__p_ScXMLNegateOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLNotOpExprDataObj[] = {  {&_swigt__p_ScXMLNotOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLObject[] = {  {&_swigt__p_ScXMLObject, 0, 0, 0},  {&_swigt__p_ScXMLAbstractStateElt, _p_ScXMLAbstractStateEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLAddOpExprDataObj, _p_ScXMLAddOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLAnchorElt, _p_ScXMLAnchorEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLAndOpExprDataObj, _p_ScXMLAndOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLAppendOpExprDataObj, _p_ScXMLAppendOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLAssignElt, _p_ScXMLAssignEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLBoolDataObj, _p_ScXMLBoolDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinAddOpExprDataObj, _p_ScXMLCoinAddOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinDivideOpExprDataObj, _p_ScXMLCoinDivideOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinEqualsOpExprDataObj, _p_ScXMLCoinEqualsOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinEvaluator, _p_ScXMLCoinEvaluatorTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinLengthFuncExprDataObj, _p_ScXMLCoinLengthFuncExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinMultiplyOpExprDataObj, _p_ScXMLCoinMultiplyOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLCoinSubtractOpExprDataObj, _p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLConstantDataObj, _p_ScXMLConstantDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLContentElt, _p_ScXMLContentEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLDataElt, _p_ScXMLDataEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLDataModelElt, _p_ScXMLDataModelEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLDataObj, _p_ScXMLDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLDivideOpExprDataObj, _p_ScXMLDivideOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLDocument, _p_ScXMLDocumentTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLECMAScriptEvaluator, _p_ScXMLECMAScriptEvaluatorTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLElseElt, _p_ScXMLElseEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLElseIfElt, _p_ScXMLElseIfEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLElt, _p_ScXMLEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLEqualsOpExprDataObj, _p_ScXMLEqualsOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLEvaluator, _p_ScXMLEvaluatorTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLEvent, _p_ScXMLEventTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLEventElt, _p_ScXMLEventEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLEventTarget, _p_ScXMLEventTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLExecutableElt, _p_ScXMLExecutableEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLExprDataObj, _p_ScXMLExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLFinalElt, _p_ScXMLFinalEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLFinalizeElt, _p_ScXMLFinalizeEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLHistoryElt, _p_ScXMLHistoryEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLIfElt, _p_ScXMLIfEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLInExprDataObj, _p_ScXMLInExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLInitialElt, _p_ScXMLInitialEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLInvokeElt, _p_ScXMLInvokeEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLLogElt, _p_ScXMLLogEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLMinimumEvaluator, _p_ScXMLMinimumEvaluatorTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLMinimumExprDataObj, _p_ScXMLMinimumExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLMultiplyOpExprDataObj, _p_ScXMLMultiplyOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLNegateOpExprDataObj, _p_ScXMLNegateOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLNotOpExprDataObj, _p_ScXMLNotOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLOnEntryElt, _p_ScXMLOnEntryEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLOnExitElt, _p_ScXMLOnExitEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLOrOpExprDataObj, _p_ScXMLOrOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLParallelElt, _p_ScXMLParallelEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLParamElt, _p_ScXMLParamEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLRealDataObj, _p_ScXMLRealDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLReferenceDataObj, _p_ScXMLReferenceDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLSbDataObj, _p_ScXMLSbDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLScriptElt, _p_ScXMLScriptEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLScxmlElt, _p_ScXMLScxmlEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLSendElt, _p_ScXMLSendEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLStateElt, _p_ScXMLStateEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLStateMachine, _p_ScXMLStateMachineTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLStringDataObj, _p_ScXMLStringDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLSubtractOpExprDataObj, _p_ScXMLSubtractOpExprDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLTransitionElt, _p_ScXMLTransitionEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLValidateElt, _p_ScXMLValidateEltTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLXMLDataObj, _p_ScXMLXMLDataObjTo_p_ScXMLObject, 0, 0},  {&_swigt__p_ScXMLXPathEvaluator, _p_ScXMLXPathEvaluatorTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLDollyTarget, _p_SoScXMLDollyTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLEvent, _p_SoScXMLEventTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLFlightControlTarget, _p_SoScXMLFlightControlTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLMiscTarget, _p_SoScXMLMiscTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLMotionTarget, _p_SoScXMLMotionTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLNavigationTarget, _p_SoScXMLNavigationTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLPanTarget, _p_SoScXMLPanTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLRotateTarget, _p_SoScXMLRotateTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLSeekTarget, _p_SoScXMLSeekTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLSpinTarget, _p_SoScXMLSpinTargetTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLStateMachine, _p_SoScXMLStateMachineTo_p_ScXMLObject, 0, 0},  {&_swigt__p_SoScXMLZoomTarget, _p_SoScXMLZoomTargetTo_p_ScXMLObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLOnEntryElt[] = {  {&_swigt__p_ScXMLOnEntryElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLOnExitElt[] = {  {&_swigt__p_ScXMLOnExitElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLOrOpExprDataObj[] = {  {&_swigt__p_ScXMLOrOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLParallelElt[] = {  {&_swigt__p_ScXMLParallelElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLParamElt[] = {  {&_swigt__p_ScXMLParamElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLRealDataObj[] = {  {&_swigt__p_ScXMLRealDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLReferenceDataObj[] = {  {&_swigt__p_ScXMLReferenceDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLSbDataObj[] = {  {&_swigt__p_ScXMLSbDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLScriptElt[] = {  {&_swigt__p_ScXMLScriptElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLScxmlElt[] = {  {&_swigt__p_ScXMLScxmlElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLSendElt[] = {  {&_swigt__p_ScXMLSendElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLStateElt[] = {  {&_swigt__p_ScXMLStateElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLStateMachine[] = {  {&_swigt__p_ScXMLStateMachine, 0, 0, 0},  {&_swigt__p_SoScXMLStateMachine, _p_SoScXMLStateMachineTo_p_ScXMLStateMachine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLStringDataObj[] = {  {&_swigt__p_ScXMLStringDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLSubtractOpExprDataObj[] = {  {&_swigt__p_ScXMLSubtractOpExprDataObj, 0, 0, 0},  {&_swigt__p_ScXMLCoinSubtractOpExprDataObj, _p_ScXMLCoinSubtractOpExprDataObjTo_p_ScXMLSubtractOpExprDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLTransitionElt[] = {  {&_swigt__p_ScXMLTransitionElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLValidateElt[] = {  {&_swigt__p_ScXMLValidateElt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLXMLDataObj[] = {  {&_swigt__p_ScXMLXMLDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScXMLXPathEvaluator[] = {  {&_swigt__p_ScXMLXPathEvaluator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAccumulatedElement[] = {  {&_swigt__p_SoAccumulatedElement, 0, 0, 0},  {&_swigt__p_SoBBoxModelMatrixElement, _p_SoBBoxModelMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoBumpMapMatrixElement, _p_SoBumpMapMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoClipPlaneElement, _p_SoClipPlaneElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoGLClipPlaneElement, _p_SoGLClipPlaneElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoGLModelMatrixElement, _p_SoGLModelMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoGLMultiTextureMatrixElement, _p_SoGLMultiTextureMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoGLVertexAttributeElement, _p_SoGLVertexAttributeElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoLightElement, _p_SoLightElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoModelMatrixElement, _p_SoModelMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoMultiTextureMatrixElement, _p_SoMultiTextureMatrixElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoProfileElement, _p_SoProfileElementTo_p_SoAccumulatedElement, 0, 0},  {&_swigt__p_SoVertexAttributeElement, _p_SoVertexAttributeElementTo_p_SoAccumulatedElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAction[] = {  {&_swigt__p_SoAction, 0, 0, 0},  {&_swigt__p_SoAudioRenderAction, _p_SoAudioRenderActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoBoxHighlightRenderAction, _p_SoBoxHighlightRenderActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoCallbackAction, _p_SoCallbackActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoGLRenderAction, _p_SoGLRenderActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoGetBoundingBoxAction, _p_SoGetBoundingBoxActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoGetMatrixAction, _p_SoGetMatrixActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoGetPrimitiveCountAction, _p_SoGetPrimitiveCountActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoHandleEventAction, _p_SoHandleEventActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoIntersectionDetectionAction, _p_SoIntersectionDetectionActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoLineHighlightRenderAction, _p_SoLineHighlightRenderActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoPickAction, _p_SoPickActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoRayPickAction, _p_SoRayPickActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoReorganizeAction, _p_SoReorganizeActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoSearchAction, _p_SoSearchActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoSimplifyAction, _p_SoSimplifyActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoToVRML2Action, _p_SoToVRML2ActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoToVRMLAction, _p_SoToVRMLActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoVectorizeAction, _p_SoVectorizeActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoVectorizePSAction, _p_SoVectorizePSActionTo_p_SoAction, 0, 0},  {&_swigt__p_SoWriteAction, _p_SoWriteActionTo_p_SoAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoActionMethodList[] = {  {&_swigt__p_SoActionMethodList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAlarmSensor[] = {  {&_swigt__p_SoAlarmSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAlphaTest[] = {  {&_swigt__p_SoAlphaTest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAmbientColorElement[] = {  {&_swigt__p_SoAmbientColorElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAnnoText3CharOrientElement[] = {  {&_swigt__p_SoAnnoText3CharOrientElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAnnoText3FontSizeHintElement[] = {  {&_swigt__p_SoAnnoText3FontSizeHintElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAnnoText3RenderPrintElement[] = {  {&_swigt__p_SoAnnoText3RenderPrintElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAnnotation[] = {  {&_swigt__p_SoAnnotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAntiSquish[] = {  {&_swigt__p_SoAntiSquish, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAppearanceKit[] = {  {&_swigt__p_SoAppearanceKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoArray[] = {  {&_swigt__p_SoArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAsciiText[] = {  {&_swigt__p_SoAsciiText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAudioDevice[] = {  {&_swigt__p_SoAudioDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAudioRenderAction[] = {  {&_swigt__p_SoAudioRenderAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoAuditorList[] = {  {&_swigt__p_SoAuditorList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBBoxModelMatrixElement[] = {  {&_swigt__p_SoBBoxModelMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBase[] = {  {&_swigt__p_SoBase, 0, 0, 0},  {&_swigt__p_SoAlphaTest, _p_SoAlphaTestTo_p_SoBase, 0, 0},  {&_swigt__p_SoAnnotation, _p_SoAnnotationTo_p_SoBase, 0, 0},  {&_swigt__p_SoAntiSquish, _p_SoAntiSquishTo_p_SoBase, 0, 0},  {&_swigt__p_SoAppearanceKit, _p_SoAppearanceKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoArray, _p_SoArrayTo_p_SoBase, 0, 0},  {&_swigt__p_SoAsciiText, _p_SoAsciiTextTo_p_SoBase, 0, 0},  {&_swigt__p_SoBaseColor, _p_SoBaseColorTo_p_SoBase, 0, 0},  {&_swigt__p_SoBaseKit, _p_SoBaseKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoBlinker, _p_SoBlinkerTo_p_SoBase, 0, 0},  {&_swigt__p_SoBoolOperation, _p_SoBoolOperationTo_p_SoBase, 0, 0},  {&_swigt__p_SoBumpMap, _p_SoBumpMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoBumpMapCoordinate, _p_SoBumpMapCoordinateTo_p_SoBase, 0, 0},  {&_swigt__p_SoBumpMapTransform, _p_SoBumpMapTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoCacheHint, _p_SoCacheHintTo_p_SoBase, 0, 0},  {&_swigt__p_SoCalculator, _p_SoCalculatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoCallback, _p_SoCallbackTo_p_SoBase, 0, 0},  {&_swigt__p_SoCamera, _p_SoCameraTo_p_SoBase, 0, 0},  {&_swigt__p_SoCameraKit, _p_SoCameraKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoClipPlane, _p_SoClipPlaneTo_p_SoBase, 0, 0},  {&_swigt__p_SoClipPlaneManip, _p_SoClipPlaneManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoColorIndex, _p_SoColorIndexTo_p_SoBase, 0, 0},  {&_swigt__p_SoComplexity, _p_SoComplexityTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeMatrix, _p_SoComposeMatrixTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeRotation, _p_SoComposeRotationTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeRotationFromTo, _p_SoComposeRotationFromToTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeVec2f, _p_SoComposeVec2fTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeVec3f, _p_SoComposeVec3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoComposeVec4f, _p_SoComposeVec4fTo_p_SoBase, 0, 0},  {&_swigt__p_SoComputeBoundingBox, _p_SoComputeBoundingBoxTo_p_SoBase, 0, 0},  {&_swigt__p_SoConcatenate, _p_SoConcatenateTo_p_SoBase, 0, 0},  {&_swigt__p_SoCone, _p_SoConeTo_p_SoBase, 0, 0},  {&_swigt__p_SoCoordinate3, _p_SoCoordinate3To_p_SoBase, 0, 0},  {&_swigt__p_SoCoordinate4, _p_SoCoordinate4To_p_SoBase, 0, 0},  {&_swigt__p_SoCounter, _p_SoCounterTo_p_SoBase, 0, 0},  {&_swigt__p_SoCube, _p_SoCubeTo_p_SoBase, 0, 0},  {&_swigt__p_SoCylinder, _p_SoCylinderTo_p_SoBase, 0, 0},  {&_swigt__p_SoDecomposeMatrix, _p_SoDecomposeMatrixTo_p_SoBase, 0, 0},  {&_swigt__p_SoDecomposeRotation, _p_SoDecomposeRotationTo_p_SoBase, 0, 0},  {&_swigt__p_SoDecomposeVec2f, _p_SoDecomposeVec2fTo_p_SoBase, 0, 0},  {&_swigt__p_SoDecomposeVec3f, _p_SoDecomposeVec3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoDecomposeVec4f, _p_SoDecomposeVec4fTo_p_SoBase, 0, 0},  {&_swigt__p_SoDepthBuffer, _p_SoDepthBufferTo_p_SoBase, 0, 0},  {&_swigt__p_SoDirectionalLight, _p_SoDirectionalLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoDirectionalLightManip, _p_SoDirectionalLightManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoDragger, _p_SoDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoDrawStyle, _p_SoDrawStyleTo_p_SoBase, 0, 0},  {&_swigt__p_SoElapsedTime, _p_SoElapsedTimeTo_p_SoBase, 0, 0},  {&_swigt__p_SoEngine, _p_SoEngineTo_p_SoBase, 0, 0},  {&_swigt__p_SoEnvironment, _p_SoEnvironmentTo_p_SoBase, 0, 0},  {&_swigt__p_SoEventCallback, _p_SoEventCallbackTo_p_SoBase, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoBase, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoFieldContainer, _p_SoFieldContainerTo_p_SoBase, 0, 0},  {&_swigt__p_SoFieldConverter, _p_SoFieldConverterTo_p_SoBase, 0, 0},  {&_swigt__p_SoFile, _p_SoFileTo_p_SoBase, 0, 0},  {&_swigt__p_SoFont, _p_SoFontTo_p_SoBase, 0, 0},  {&_swigt__p_SoFontStyle, _p_SoFontStyleTo_p_SoBase, 0, 0},  {&_swigt__p_SoFragmentShader, _p_SoFragmentShaderTo_p_SoBase, 0, 0},  {&_swigt__p_SoFrustumCamera, _p_SoFrustumCameraTo_p_SoBase, 0, 0},  {&_swigt__p_SoFullPath, _p_SoFullPathTo_p_SoBase, 0, 0},  {&_swigt__p_SoGate, _p_SoGateTo_p_SoBase, 0, 0},  {&_swigt__p_SoGeoCoordinate, _p_SoGeoCoordinateTo_p_SoBase, 0, 0},  {&_swigt__p_SoGeoLocation, _p_SoGeoLocationTo_p_SoBase, 0, 0},  {&_swigt__p_SoGeoOrigin, _p_SoGeoOriginTo_p_SoBase, 0, 0},  {&_swigt__p_SoGeoSeparator, _p_SoGeoSeparatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoGroup, _p_SoGroupTo_p_SoBase, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoHeightMapToNormalMap, _p_SoHeightMapToNormalMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoImage, _p_SoImageTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedNurbsCurve, _p_SoIndexedNurbsCurveTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedNurbsSurface, _p_SoIndexedNurbsSurfaceTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedShape, _p_SoIndexedShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoInfo, _p_SoInfoTo_p_SoBase, 0, 0},  {&_swigt__p_SoInteractionKit, _p_SoInteractionKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolate, _p_SoInterpolateTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolateFloat, _p_SoInterpolateFloatTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolateRotation, _p_SoInterpolateRotationTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolateVec2f, _p_SoInterpolateVec2fTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolateVec3f, _p_SoInterpolateVec3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoInterpolateVec4f, _p_SoInterpolateVec4fTo_p_SoBase, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoLOD, _p_SoLODTo_p_SoBase, 0, 0},  {&_swigt__p_SoLabel, _p_SoLabelTo_p_SoBase, 0, 0},  {&_swigt__p_SoLevelOfDetail, _p_SoLevelOfDetailTo_p_SoBase, 0, 0},  {&_swigt__p_SoLight, _p_SoLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoLightKit, _p_SoLightKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoLightModel, _p_SoLightModelTo_p_SoBase, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoLinearProfile, _p_SoLinearProfileTo_p_SoBase, 0, 0},  {&_swigt__p_SoListener, _p_SoListenerTo_p_SoBase, 0, 0},  {&_swigt__p_SoLocateHighlight, _p_SoLocateHighlightTo_p_SoBase, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoMaterial, _p_SoMaterialTo_p_SoBase, 0, 0},  {&_swigt__p_SoMaterialBinding, _p_SoMaterialBindingTo_p_SoBase, 0, 0},  {&_swigt__p_SoMatrixTransform, _p_SoMatrixTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoMultipleCopy, _p_SoMultipleCopyTo_p_SoBase, 0, 0},  {&_swigt__p_SoNode, _p_SoNodeTo_p_SoBase, 0, 0},  {&_swigt__p_SoNodeEngine, _p_SoNodeEngineTo_p_SoBase, 0, 0},  {&_swigt__p_SoNodeKitListPart, _p_SoNodeKitListPartTo_p_SoBase, 0, 0},  {&_swigt__p_SoNodeKitPath, _p_SoNodeKitPathTo_p_SoBase, 0, 0},  {&_swigt__p_SoNonIndexedShape, _p_SoNonIndexedShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoNormal, _p_SoNormalTo_p_SoBase, 0, 0},  {&_swigt__p_SoNormalBinding, _p_SoNormalBindingTo_p_SoBase, 0, 0},  {&_swigt__p_SoNurbsCurve, _p_SoNurbsCurveTo_p_SoBase, 0, 0},  {&_swigt__p_SoNurbsProfile, _p_SoNurbsProfileTo_p_SoBase, 0, 0},  {&_swigt__p_SoNurbsSurface, _p_SoNurbsSurfaceTo_p_SoBase, 0, 0},  {&_swigt__p_SoOnOff, _p_SoOnOffTo_p_SoBase, 0, 0},  {&_swigt__p_SoOneShot, _p_SoOneShotTo_p_SoBase, 0, 0},  {&_swigt__p_SoOrthographicCamera, _p_SoOrthographicCameraTo_p_SoBase, 0, 0},  {&_swigt__p_SoPackedColor, _p_SoPackedColorTo_p_SoBase, 0, 0},  {&_swigt__p_SoPath, _p_SoPathTo_p_SoBase, 0, 0},  {&_swigt__p_SoPathSwitch, _p_SoPathSwitchTo_p_SoBase, 0, 0},  {&_swigt__p_SoPendulum, _p_SoPendulumTo_p_SoBase, 0, 0},  {&_swigt__p_SoPerspectiveCamera, _p_SoPerspectiveCameraTo_p_SoBase, 0, 0},  {&_swigt__p_SoPickStyle, _p_SoPickStyleTo_p_SoBase, 0, 0},  {&_swigt__p_SoPointLight, _p_SoPointLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoPointLightManip, _p_SoPointLightManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoPolygonOffset, _p_SoPolygonOffsetTo_p_SoBase, 0, 0},  {&_swigt__p_SoProfile, _p_SoProfileTo_p_SoBase, 0, 0},  {&_swigt__p_SoProfileCoordinate2, _p_SoProfileCoordinate2To_p_SoBase, 0, 0},  {&_swigt__p_SoProfileCoordinate3, _p_SoProfileCoordinate3To_p_SoBase, 0, 0},  {&_swigt__p_SoProto, _p_SoProtoTo_p_SoBase, 0, 0},  {&_swigt__p_SoProtoInstance, _p_SoProtoInstanceTo_p_SoBase, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoBase, 0, 0},  {&_swigt__p_SoResetTransform, _p_SoResetTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoReversePerspectiveCamera, _p_SoReversePerspectiveCameraTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotation, _p_SoRotationTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotationXYZ, _p_SoRotationXYZTo_p_SoBase, 0, 0},  {&_swigt__p_SoRotor, _p_SoRotorTo_p_SoBase, 0, 0},  {&_swigt__p_SoScale, _p_SoScaleTo_p_SoBase, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoSceneKit, _p_SoSceneKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoSceneTexture2, _p_SoSceneTexture2To_p_SoBase, 0, 0},  {&_swigt__p_SoSceneTextureCubeMap, _p_SoSceneTextureCubeMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoSelectOne, _p_SoSelectOneTo_p_SoBase, 0, 0},  {&_swigt__p_SoSelection, _p_SoSelectionTo_p_SoBase, 0, 0},  {&_swigt__p_SoSeparator, _p_SoSeparatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoSeparatorKit, _p_SoSeparatorKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderObject, _p_SoShaderObjectTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter, _p_SoShaderParameterTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter1f, _p_SoShaderParameter1fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter1i, _p_SoShaderParameter1iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter2f, _p_SoShaderParameter2fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter2i, _p_SoShaderParameter2iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter3f, _p_SoShaderParameter3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter3i, _p_SoShaderParameter3iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter4f, _p_SoShaderParameter4fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameter4i, _p_SoShaderParameter4iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray1f, _p_SoShaderParameterArray1fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray1i, _p_SoShaderParameterArray1iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray2f, _p_SoShaderParameterArray2fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray2i, _p_SoShaderParameterArray2iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray3f, _p_SoShaderParameterArray3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray3i, _p_SoShaderParameterArray3iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray4f, _p_SoShaderParameterArray4fTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterArray4i, _p_SoShaderParameterArray4iTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterMatrix, _p_SoShaderParameterMatrixTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderParameterMatrixArray, _p_SoShaderParameterMatrixArrayTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderProgram, _p_SoShaderProgramTo_p_SoBase, 0, 0},  {&_swigt__p_SoShaderStateMatrixParameter, _p_SoShaderStateMatrixParameterTo_p_SoBase, 0, 0},  {&_swigt__p_SoShape, _p_SoShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoShapeHints, _p_SoShapeHintsTo_p_SoBase, 0, 0},  {&_swigt__p_SoShapeKit, _p_SoShapeKitTo_p_SoBase, 0, 0},  {&_swigt__p_SoShuttle, _p_SoShuttleTo_p_SoBase, 0, 0},  {&_swigt__p_SoSphere, _p_SoSphereTo_p_SoBase, 0, 0},  {&_swigt__p_SoSpotLight, _p_SoSpotLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoSpotLightManip, _p_SoSpotLightManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoSurroundScale, _p_SoSurroundScaleTo_p_SoBase, 0, 0},  {&_swigt__p_SoSwitch, _p_SoSwitchTo_p_SoBase, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTempPath, _p_SoTempPathTo_p_SoBase, 0, 0},  {&_swigt__p_SoText2, _p_SoText2To_p_SoBase, 0, 0},  {&_swigt__p_SoText3, _p_SoText3To_p_SoBase, 0, 0},  {&_swigt__p_SoTexture, _p_SoTextureTo_p_SoBase, 0, 0},  {&_swigt__p_SoTexture2, _p_SoTexture2To_p_SoBase, 0, 0},  {&_swigt__p_SoTexture2Convert, _p_SoTexture2ConvertTo_p_SoBase, 0, 0},  {&_swigt__p_SoTexture2Transform, _p_SoTexture2TransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoTexture3, _p_SoTexture3To_p_SoBase, 0, 0},  {&_swigt__p_SoTexture3Transform, _p_SoTexture3TransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCombine, _p_SoTextureCombineTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinate2, _p_SoTextureCoordinate2To_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinate3, _p_SoTextureCoordinate3To_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateBinding, _p_SoTextureCoordinateBindingTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateCube, _p_SoTextureCoordinateCubeTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateCylinder, _p_SoTextureCoordinateCylinderTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateDefault, _p_SoTextureCoordinateDefaultTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateEnvironment, _p_SoTextureCoordinateEnvironmentTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateFunction, _p_SoTextureCoordinateFunctionTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateNormalMap, _p_SoTextureCoordinateNormalMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateObject, _p_SoTextureCoordinateObjectTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinatePlane, _p_SoTextureCoordinatePlaneTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateReflectionMap, _p_SoTextureCoordinateReflectionMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCoordinateSphere, _p_SoTextureCoordinateSphereTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureCubeMap, _p_SoTextureCubeMapTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureMatrixTransform, _p_SoTextureMatrixTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureScalePolicy, _p_SoTextureScalePolicyTo_p_SoBase, 0, 0},  {&_swigt__p_SoTextureUnit, _p_SoTextureUnitTo_p_SoBase, 0, 0},  {&_swigt__p_SoTimeCounter, _p_SoTimeCounterTo_p_SoBase, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransform, _p_SoTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformManip, _p_SoTransformManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformSeparator, _p_SoTransformSeparatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformVec3f, _p_SoTransformVec3fTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformation, _p_SoTransformationTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoBase, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoBase, 0, 0},  {&_swigt__p_SoTranslation, _p_SoTranslationTo_p_SoBase, 0, 0},  {&_swigt__p_SoTransparencyType, _p_SoTransparencyTypeTo_p_SoBase, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoTriggerAny, _p_SoTriggerAnyTo_p_SoBase, 0, 0},  {&_swigt__p_SoUniformShaderParameter, _p_SoUniformShaderParameterTo_p_SoBase, 0, 0},  {&_swigt__p_SoUnits, _p_SoUnitsTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLAnchor, _p_SoVRMLAnchorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLAppearance, _p_SoVRMLAppearanceTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLAudioClip, _p_SoVRMLAudioClipTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLBackground, _p_SoVRMLBackgroundTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLBillboard, _p_SoVRMLBillboardTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLBox, _p_SoVRMLBoxTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLColor, _p_SoVRMLColorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLColorInterpolator, _p_SoVRMLColorInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCone, _p_SoVRMLConeTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCoordinate, _p_SoVRMLCoordinateTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCoordinateInterpolator, _p_SoVRMLCoordinateInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCylinder, _p_SoVRMLCylinderTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLCylinderSensor, _p_SoVRMLCylinderSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLDirectionalLight, _p_SoVRMLDirectionalLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLDragSensor, _p_SoVRMLDragSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLElevationGrid, _p_SoVRMLElevationGridTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLExtrusion, _p_SoVRMLExtrusionTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLFog, _p_SoVRMLFogTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLFontStyle, _p_SoVRMLFontStyleTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLGeometry, _p_SoVRMLGeometryTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLGroup, _p_SoVRMLGroupTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLImageTexture, _p_SoVRMLImageTextureTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLInline, _p_SoVRMLInlineTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLInterpolator, _p_SoVRMLInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLLOD, _p_SoVRMLLODTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLLight, _p_SoVRMLLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLMaterial, _p_SoVRMLMaterialTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLMovieTexture, _p_SoVRMLMovieTextureTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLNavigationInfo, _p_SoVRMLNavigationInfoTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLNormal, _p_SoVRMLNormalTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLNormalInterpolator, _p_SoVRMLNormalInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLOrientationInterpolator, _p_SoVRMLOrientationInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLParent, _p_SoVRMLParentTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLPixelTexture, _p_SoVRMLPixelTextureTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLPlaneSensor, _p_SoVRMLPlaneSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLPointLight, _p_SoVRMLPointLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLPositionInterpolator, _p_SoVRMLPositionInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLProximitySensor, _p_SoVRMLProximitySensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLScalarInterpolator, _p_SoVRMLScalarInterpolatorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLScript, _p_SoVRMLScriptTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSensor, _p_SoVRMLSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLShape, _p_SoVRMLShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSound, _p_SoVRMLSoundTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSphere, _p_SoVRMLSphereTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSphereSensor, _p_SoVRMLSphereSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSpotLight, _p_SoVRMLSpotLightTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLSwitch, _p_SoVRMLSwitchTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLText, _p_SoVRMLTextTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTexture, _p_SoVRMLTextureTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTextureCoordinate, _p_SoVRMLTextureCoordinateTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTextureTransform, _p_SoVRMLTextureTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTimeSensor, _p_SoVRMLTimeSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTouchSensor, _p_SoVRMLTouchSensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLVertexLine, _p_SoVRMLVertexLineTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLVertexPoint, _p_SoVRMLVertexPointTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLVertexShape, _p_SoVRMLVertexShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLViewpoint, _p_SoVRMLViewpointTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLVisibilitySensor, _p_SoVRMLVisibilitySensorTo_p_SoBase, 0, 0},  {&_swigt__p_SoVRMLWorldInfo, _p_SoVRMLWorldInfoTo_p_SoBase, 0, 0},  {&_swigt__p_SoVertexAttribute, _p_SoVertexAttributeTo_p_SoBase, 0, 0},  {&_swigt__p_SoVertexAttributeBinding, _p_SoVertexAttributeBindingTo_p_SoBase, 0, 0},  {&_swigt__p_SoVertexProperty, _p_SoVertexPropertyTo_p_SoBase, 0, 0},  {&_swigt__p_SoVertexShader, _p_SoVertexShaderTo_p_SoBase, 0, 0},  {&_swigt__p_SoVertexShape, _p_SoVertexShapeTo_p_SoBase, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoBase, 0, 0},  {&_swigt__p_SoWWWInline, _p_SoWWWInlineTo_p_SoBase, 0, 0},  {&_swigt__p_SoWrapperKit, _p_SoWrapperKitTo_p_SoBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBaseColor[] = {  {&_swigt__p_SoBaseColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBaseKit[] = {  {&_swigt__p_SoBaseKit, 0, 0, 0},  {&_swigt__p_SoAppearanceKit, _p_SoAppearanceKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoCameraKit, _p_SoCameraKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoDragger, _p_SoDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoInteractionKit, _p_SoInteractionKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoLightKit, _p_SoLightKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoSceneKit, _p_SoSceneKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoSeparatorKit, _p_SoSeparatorKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoShapeKit, _p_SoShapeKitTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoBaseKit, 0, 0},  {&_swigt__p_SoWrapperKit, _p_SoWrapperKitTo_p_SoBaseKit, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBaseList[] = {  {&_swigt__p_SoBaseList, 0, 0, 0},  {&_swigt__p_SoChildList, _p_SoChildListTo_p_SoBaseList, 0, 0},  {&_swigt__p_SoEngineList, _p_SoEngineListTo_p_SoBaseList, 0, 0},  {&_swigt__p_SoNodeList, _p_SoNodeListTo_p_SoBaseList, 0, 0},  {&_swigt__p_SoPathList, _p_SoPathListTo_p_SoBaseList, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBlinker[] = {  {&_swigt__p_SoBlinker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBoolOperation[] = {  {&_swigt__p_SoBoolOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBoundingBoxCache[] = {  {&_swigt__p_SoBoundingBoxCache, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBoxHighlightRenderAction[] = {  {&_swigt__p_SoBoxHighlightRenderAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMap[] = {  {&_swigt__p_SoBumpMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMapCoordinate[] = {  {&_swigt__p_SoBumpMapCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMapCoordinateElement[] = {  {&_swigt__p_SoBumpMapCoordinateElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMapElement[] = {  {&_swigt__p_SoBumpMapElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMapMatrixElement[] = {  {&_swigt__p_SoBumpMapMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBumpMapTransform[] = {  {&_swigt__p_SoBumpMapTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBundle[] = {  {&_swigt__p_SoBundle, 0, 0, 0},  {&_swigt__p_SoMaterialBundle, _p_SoMaterialBundleTo_p_SoBundle, 0, 0},  {&_swigt__p_SoNormalBundle, _p_SoNormalBundleTo_p_SoBundle, 0, 0},  {&_swigt__p_SoTextureCoordinateBundle, _p_SoTextureCoordinateBundleTo_p_SoBundle, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoButtonEvent[] = {  {&_swigt__p_SoButtonEvent, 0, 0, 0},  {&_swigt__p_SoKeyboardEvent, _p_SoKeyboardEventTo_p_SoButtonEvent, 0, 0},  {&_swigt__p_SoMouseButtonEvent, _p_SoMouseButtonEventTo_p_SoButtonEvent, 0, 0},  {&_swigt__p_SoSpaceballButtonEvent, _p_SoSpaceballButtonEventTo_p_SoButtonEvent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoByteStream[] = {  {&_swigt__p_SoByteStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCache[] = {  {&_swigt__p_SoCache, 0, 0, 0},  {&_swigt__p_SoBoundingBoxCache, _p_SoBoundingBoxCacheTo_p_SoCache, 0, 0},  {&_swigt__p_SoConvexDataCache, _p_SoConvexDataCacheTo_p_SoCache, 0, 0},  {&_swigt__p_SoGLRenderCache, _p_SoGLRenderCacheTo_p_SoCache, 0, 0},  {&_swigt__p_SoNormalCache, _p_SoNormalCacheTo_p_SoCache, 0, 0},  {&_swigt__p_SoTextureCoordinateCache, _p_SoTextureCoordinateCacheTo_p_SoCache, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCacheElement[] = {  {&_swigt__p_SoCacheElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCacheHint[] = {  {&_swigt__p_SoCacheHint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCacheHintElement[] = {  {&_swigt__p_SoCacheHintElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCalculator[] = {  {&_swigt__p_SoCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCallback[] = {  {&_swigt__p_SoCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCallbackAction[] = {  {&_swigt__p_SoCallbackAction, 0, 0, 0},  {&_swigt__p_SoVectorizeAction, _p_SoVectorizeActionTo_p_SoCallbackAction, 0, 0},  {&_swigt__p_SoVectorizePSAction, _p_SoVectorizePSActionTo_p_SoCallbackAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCallbackActionCB[] = {  {&_swigt__p_SoCallbackActionCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCallbackList[] = {  {&_swigt__p_SoCallbackList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCamera[] = {  {&_swigt__p_SoCamera, 0, 0, 0},  {&_swigt__p_SoFrustumCamera, _p_SoFrustumCameraTo_p_SoCamera, 0, 0},  {&_swigt__p_SoOrthographicCamera, _p_SoOrthographicCameraTo_p_SoCamera, 0, 0},  {&_swigt__p_SoPerspectiveCamera, _p_SoPerspectiveCameraTo_p_SoCamera, 0, 0},  {&_swigt__p_SoReversePerspectiveCamera, _p_SoReversePerspectiveCameraTo_p_SoCamera, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCameraKit[] = {  {&_swigt__p_SoCameraKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCenterballDragger[] = {  {&_swigt__p_SoCenterballDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCenterballManip[] = {  {&_swigt__p_SoCenterballManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoChildList[] = {  {&_swigt__p_SoChildList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoClipPlane[] = {  {&_swigt__p_SoClipPlane, 0, 0, 0},  {&_swigt__p_SoClipPlaneManip, _p_SoClipPlaneManipTo_p_SoClipPlane, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoClipPlaneElement[] = {  {&_swigt__p_SoClipPlaneElement, 0, 0, 0},  {&_swigt__p_SoGLClipPlaneElement, _p_SoGLClipPlaneElementTo_p_SoClipPlaneElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoClipPlaneManip[] = {  {&_swigt__p_SoClipPlaneManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoColorIndex[] = {  {&_swigt__p_SoColorIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoColorPacker[] = {  {&_swigt__p_SoColorPacker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComplexity[] = {  {&_swigt__p_SoComplexity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComplexityElement[] = {  {&_swigt__p_SoComplexityElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComplexityTypeElement[] = {  {&_swigt__p_SoComplexityTypeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeMatrix[] = {  {&_swigt__p_SoComposeMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeRotation[] = {  {&_swigt__p_SoComposeRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeRotationFromTo[] = {  {&_swigt__p_SoComposeRotationFromTo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeVec2f[] = {  {&_swigt__p_SoComposeVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeVec3f[] = {  {&_swigt__p_SoComposeVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComposeVec4f[] = {  {&_swigt__p_SoComposeVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoComputeBoundingBox[] = {  {&_swigt__p_SoComputeBoundingBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoConcatenate[] = {  {&_swigt__p_SoConcatenate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCone[] = {  {&_swigt__p_SoCone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoConeDetail[] = {  {&_swigt__p_SoConeDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoContextHandler[] = {  {&_swigt__p_SoContextHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoConvexDataCache[] = {  {&_swigt__p_SoConvexDataCache, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCoordinate3[] = {  {&_swigt__p_SoCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCoordinate4[] = {  {&_swigt__p_SoCoordinate4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCoordinateElement[] = {  {&_swigt__p_SoCoordinateElement, 0, 0, 0},  {&_swigt__p_SoGLCoordinateElement, _p_SoGLCoordinateElementTo_p_SoCoordinateElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCounter[] = {  {&_swigt__p_SoCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCreaseAngleElement[] = {  {&_swigt__p_SoCreaseAngleElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCube[] = {  {&_swigt__p_SoCube, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCubeDetail[] = {  {&_swigt__p_SoCubeDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCullElement[] = {  {&_swigt__p_SoCullElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCylinder[] = {  {&_swigt__p_SoCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoCylinderDetail[] = {  {&_swigt__p_SoCylinderDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDB[] = {  {&_swigt__p_SoDB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDataSensor[] = {  {&_swigt__p_SoDataSensor, 0, 0, 0},  {&_swigt__p_SoFieldSensor, _p_SoFieldSensorTo_p_SoDataSensor, 0, 0},  {&_swigt__p_SoNodeSensor, _p_SoNodeSensorTo_p_SoDataSensor, 0, 0},  {&_swigt__p_SoPathSensor, _p_SoPathSensorTo_p_SoDataSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDebugError[] = {  {&_swigt__p_SoDebugError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecimationPercentageElement[] = {  {&_swigt__p_SoDecimationPercentageElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecimationTypeElement[] = {  {&_swigt__p_SoDecimationTypeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecomposeMatrix[] = {  {&_swigt__p_SoDecomposeMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecomposeRotation[] = {  {&_swigt__p_SoDecomposeRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecomposeVec2f[] = {  {&_swigt__p_SoDecomposeVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecomposeVec3f[] = {  {&_swigt__p_SoDecomposeVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDecomposeVec4f[] = {  {&_swigt__p_SoDecomposeVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDelayQueueSensor[] = {  {&_swigt__p_SoDelayQueueSensor, 0, 0, 0},  {&_swigt__p_SoDataSensor, _p_SoDataSensorTo_p_SoDelayQueueSensor, 0, 0},  {&_swigt__p_SoFieldSensor, _p_SoFieldSensorTo_p_SoDelayQueueSensor, 0, 0},  {&_swigt__p_SoIdleSensor, _p_SoIdleSensorTo_p_SoDelayQueueSensor, 0, 0},  {&_swigt__p_SoNodeSensor, _p_SoNodeSensorTo_p_SoDelayQueueSensor, 0, 0},  {&_swigt__p_SoOneShotSensor, _p_SoOneShotSensorTo_p_SoDelayQueueSensor, 0, 0},  {&_swigt__p_SoPathSensor, _p_SoPathSensorTo_p_SoDelayQueueSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDepthBuffer[] = {  {&_swigt__p_SoDepthBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDepthBufferElement[] = {  {&_swigt__p_SoDepthBufferElement, 0, 0, 0},  {&_swigt__p_SoGLDepthBufferElement, _p_SoGLDepthBufferElementTo_p_SoDepthBufferElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDepthBufferElement__DepthWriteFunction[] = {  {&_swigt__p_SoDepthBufferElement__DepthWriteFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDetail[] = {  {&_swigt__p_SoDetail, 0, 0, 0},  {&_swigt__p_SoConeDetail, _p_SoConeDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoCubeDetail, _p_SoCubeDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoCylinderDetail, _p_SoCylinderDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoFaceDetail, _p_SoFaceDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoLineDetail, _p_SoLineDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoNodeKitDetail, _p_SoNodeKitDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoPointDetail, _p_SoPointDetailTo_p_SoDetail, 0, 0},  {&_swigt__p_SoTextDetail, _p_SoTextDetailTo_p_SoDetail, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDetailList[] = {  {&_swigt__p_SoDetailList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDiffuseColorElement[] = {  {&_swigt__p_SoDiffuseColorElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDirectionalLight[] = {  {&_swigt__p_SoDirectionalLight, 0, 0, 0},  {&_swigt__p_SoDirectionalLightManip, _p_SoDirectionalLightManipTo_p_SoDirectionalLight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDirectionalLightDragger[] = {  {&_swigt__p_SoDirectionalLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDirectionalLightManip[] = {  {&_swigt__p_SoDirectionalLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDragPointDragger[] = {  {&_swigt__p_SoDragPointDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDragger[] = {  {&_swigt__p_SoDragger, 0, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoDragger, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoDragger, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDrawStyle[] = {  {&_swigt__p_SoDrawStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoDrawStyleElement[] = {  {&_swigt__p_SoDrawStyleElement, 0, 0, 0},  {&_swigt__p_SoGLDrawStyleElement, _p_SoGLDrawStyleElementTo_p_SoDrawStyleElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoElapsedTime[] = {  {&_swigt__p_SoElapsedTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoElement[] = {  {&_swigt__p_SoElement, 0, 0, 0},  {&_swigt__p_SoAccumulatedElement, _p_SoAccumulatedElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoAmbientColorElement, _p_SoAmbientColorElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoAnnoText3CharOrientElement, _p_SoAnnoText3CharOrientElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoAnnoText3FontSizeHintElement, _p_SoAnnoText3FontSizeHintElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoAnnoText3RenderPrintElement, _p_SoAnnoText3RenderPrintElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoBBoxModelMatrixElement, _p_SoBBoxModelMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoBumpMapCoordinateElement, _p_SoBumpMapCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoBumpMapElement, _p_SoBumpMapElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoBumpMapMatrixElement, _p_SoBumpMapMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoCacheElement, _p_SoCacheElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoCacheHintElement, _p_SoCacheHintElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoClipPlaneElement, _p_SoClipPlaneElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoComplexityElement, _p_SoComplexityElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoComplexityTypeElement, _p_SoComplexityTypeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoCoordinateElement, _p_SoCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoCreaseAngleElement, _p_SoCreaseAngleElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoCullElement, _p_SoCullElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoDecimationPercentageElement, _p_SoDecimationPercentageElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoDecimationTypeElement, _p_SoDecimationTypeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoDepthBufferElement, _p_SoDepthBufferElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoDiffuseColorElement, _p_SoDiffuseColorElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoDrawStyleElement, _p_SoDrawStyleElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoEmissiveColorElement, _p_SoEmissiveColorElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoEnvironmentElement, _p_SoEnvironmentElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoFloatElement, _p_SoFloatElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoFocalDistanceElement, _p_SoFocalDistanceElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoFontNameElement, _p_SoFontNameElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoFontSizeElement, _p_SoFontSizeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLCacheContextElement, _p_SoGLCacheContextElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLClipPlaneElement, _p_SoGLClipPlaneElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLColorIndexElement, _p_SoGLColorIndexElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLCoordinateElement, _p_SoGLCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLDepthBufferElement, _p_SoGLDepthBufferElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLDrawStyleElement, _p_SoGLDrawStyleElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLEnvironmentElement, _p_SoGLEnvironmentElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLLazyElement, _p_SoGLLazyElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLLightIdElement, _p_SoGLLightIdElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLLinePatternElement, _p_SoGLLinePatternElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLLineWidthElement, _p_SoGLLineWidthElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLModelMatrixElement, _p_SoGLModelMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLMultiTextureCoordinateElement, _p_SoGLMultiTextureCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLMultiTextureEnabledElement, _p_SoGLMultiTextureEnabledElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLMultiTextureImageElement, _p_SoGLMultiTextureImageElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLMultiTextureMatrixElement, _p_SoGLMultiTextureMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLNormalElement, _p_SoGLNormalElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLPointSizeElement, _p_SoGLPointSizeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLPolygonOffsetElement, _p_SoGLPolygonOffsetElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLProjectionMatrixElement, _p_SoGLProjectionMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLRenderPassElement, _p_SoGLRenderPassElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLShapeHintsElement, _p_SoGLShapeHintsElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLUpdateAreaElement, _p_SoGLUpdateAreaElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLVBOElement, _p_SoGLVBOElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLVertexAttributeElement, _p_SoGLVertexAttributeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLViewingMatrixElement, _p_SoGLViewingMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoGLViewportRegionElement, _p_SoGLViewportRegionElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoInt32Element, _p_SoInt32ElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLazyElement, _p_SoLazyElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLightAttenuationElement, _p_SoLightAttenuationElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLightElement, _p_SoLightElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLightModelElement, _p_SoLightModelElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLinePatternElement, _p_SoLinePatternElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLineWidthElement, _p_SoLineWidthElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoListenerDopplerElement, _p_SoListenerDopplerElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoListenerGainElement, _p_SoListenerGainElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoListenerOrientationElement, _p_SoListenerOrientationElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoListenerPositionElement, _p_SoListenerPositionElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoLocalBBoxMatrixElement, _p_SoLocalBBoxMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoMaterialBindingElement, _p_SoMaterialBindingElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoModelMatrixElement, _p_SoModelMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoMultiTextureCoordinateElement, _p_SoMultiTextureCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoMultiTextureEnabledElement, _p_SoMultiTextureEnabledElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoMultiTextureImageElement, _p_SoMultiTextureImageElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoMultiTextureMatrixElement, _p_SoMultiTextureMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoNormalBindingElement, _p_SoNormalBindingElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoNormalElement, _p_SoNormalElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoOverrideElement, _p_SoOverrideElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoPickRayElement, _p_SoPickRayElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoPickStyleElement, _p_SoPickStyleElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoPointSizeElement, _p_SoPointSizeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoPolygonOffsetElement, _p_SoPolygonOffsetElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoProfileCoordinateElement, _p_SoProfileCoordinateElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoProfileElement, _p_SoProfileElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoProjectionMatrixElement, _p_SoProjectionMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoReplacedElement, _p_SoReplacedElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoShapeHintsElement, _p_SoShapeHintsElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoShapeStyleElement, _p_SoShapeStyleElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoShininessElement, _p_SoShininessElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoSoundElement, _p_SoSoundElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoSpecularColorElement, _p_SoSpecularColorElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoSwitchElement, _p_SoSwitchElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextOutlineEnabledElement, _p_SoTextOutlineEnabledElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextureCombineElement, _p_SoTextureCombineElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextureCoordinateBindingElement, _p_SoTextureCoordinateBindingElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextureOverrideElement, _p_SoTextureOverrideElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextureQualityElement, _p_SoTextureQualityElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTextureUnitElement, _p_SoTextureUnitElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoTransparencyElement, _p_SoTransparencyElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoUnitsElement, _p_SoUnitsElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoVertexAttributeBindingElement, _p_SoVertexAttributeBindingElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoVertexAttributeElement, _p_SoVertexAttributeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoViewVolumeElement, _p_SoViewVolumeElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoViewingMatrixElement, _p_SoViewingMatrixElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoViewportRegionElement, _p_SoViewportRegionElementTo_p_SoElement, 0, 0},  {&_swigt__p_SoWindowElement, _p_SoWindowElementTo_p_SoElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEmissiveColorElement[] = {  {&_swigt__p_SoEmissiveColorElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEnabledElementsList[] = {  {&_swigt__p_SoEnabledElementsList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEngine[] = {  {&_swigt__p_SoEngine, 0, 0, 0},  {&_swigt__p_SoBoolOperation, _p_SoBoolOperationTo_p_SoEngine, 0, 0},  {&_swigt__p_SoCalculator, _p_SoCalculatorTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeMatrix, _p_SoComposeMatrixTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeRotation, _p_SoComposeRotationTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeRotationFromTo, _p_SoComposeRotationFromToTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeVec2f, _p_SoComposeVec2fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeVec3f, _p_SoComposeVec3fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComposeVec4f, _p_SoComposeVec4fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoComputeBoundingBox, _p_SoComputeBoundingBoxTo_p_SoEngine, 0, 0},  {&_swigt__p_SoConcatenate, _p_SoConcatenateTo_p_SoEngine, 0, 0},  {&_swigt__p_SoCounter, _p_SoCounterTo_p_SoEngine, 0, 0},  {&_swigt__p_SoDecomposeMatrix, _p_SoDecomposeMatrixTo_p_SoEngine, 0, 0},  {&_swigt__p_SoDecomposeRotation, _p_SoDecomposeRotationTo_p_SoEngine, 0, 0},  {&_swigt__p_SoDecomposeVec2f, _p_SoDecomposeVec2fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoDecomposeVec3f, _p_SoDecomposeVec3fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoDecomposeVec4f, _p_SoDecomposeVec4fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoElapsedTime, _p_SoElapsedTimeTo_p_SoEngine, 0, 0},  {&_swigt__p_SoFieldConverter, _p_SoFieldConverterTo_p_SoEngine, 0, 0},  {&_swigt__p_SoGate, _p_SoGateTo_p_SoEngine, 0, 0},  {&_swigt__p_SoHeightMapToNormalMap, _p_SoHeightMapToNormalMapTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolate, _p_SoInterpolateTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolateFloat, _p_SoInterpolateFloatTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolateRotation, _p_SoInterpolateRotationTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolateVec2f, _p_SoInterpolateVec2fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolateVec3f, _p_SoInterpolateVec3fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoInterpolateVec4f, _p_SoInterpolateVec4fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoOnOff, _p_SoOnOffTo_p_SoEngine, 0, 0},  {&_swigt__p_SoOneShot, _p_SoOneShotTo_p_SoEngine, 0, 0},  {&_swigt__p_SoSelectOne, _p_SoSelectOneTo_p_SoEngine, 0, 0},  {&_swigt__p_SoTexture2Convert, _p_SoTexture2ConvertTo_p_SoEngine, 0, 0},  {&_swigt__p_SoTimeCounter, _p_SoTimeCounterTo_p_SoEngine, 0, 0},  {&_swigt__p_SoTransformVec3f, _p_SoTransformVec3fTo_p_SoEngine, 0, 0},  {&_swigt__p_SoTriggerAny, _p_SoTriggerAnyTo_p_SoEngine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEngineList[] = {  {&_swigt__p_SoEngineList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEngineOutput[] = {  {&_swigt__p_SoEngineOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEngineOutputData[] = {  {&_swigt__p_SoEngineOutputData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEngineOutputList[] = {  {&_swigt__p_SoEngineOutputList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEnvironment[] = {  {&_swigt__p_SoEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEnvironmentElement[] = {  {&_swigt__p_SoEnvironmentElement, 0, 0, 0},  {&_swigt__p_SoGLEnvironmentElement, _p_SoGLEnvironmentElementTo_p_SoEnvironmentElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoError[] = {  {&_swigt__p_SoError, 0, 0, 0},  {&_swigt__p_SoDebugError, _p_SoDebugErrorTo_p_SoError, 0, 0},  {&_swigt__p_SoMemoryError, _p_SoMemoryErrorTo_p_SoError, 0, 0},  {&_swigt__p_SoReadError, _p_SoReadErrorTo_p_SoError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEvent[] = {  {&_swigt__p_SoEvent, 0, 0, 0},  {&_swigt__p_SoButtonEvent, _p_SoButtonEventTo_p_SoEvent, 0, 0},  {&_swigt__p_SoKeyboardEvent, _p_SoKeyboardEventTo_p_SoEvent, 0, 0},  {&_swigt__p_SoLocation2Event, _p_SoLocation2EventTo_p_SoEvent, 0, 0},  {&_swigt__p_SoMotion3Event, _p_SoMotion3EventTo_p_SoEvent, 0, 0},  {&_swigt__p_SoMouseButtonEvent, _p_SoMouseButtonEventTo_p_SoEvent, 0, 0},  {&_swigt__p_SoSpaceballButtonEvent, _p_SoSpaceballButtonEventTo_p_SoEvent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEventCallback[] = {  {&_swigt__p_SoEventCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoEventManager[] = {  {&_swigt__p_SoEventManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoExtSelection[] = {  {&_swigt__p_SoExtSelection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFaceDetail[] = {  {&_swigt__p_SoFaceDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFaceSet[] = {  {&_swigt__p_SoFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoField[] = {  {&_swigt__p_SoField, 0, 0, 0},  {&_swigt__p_SoMFBitMask, _p_SoMFBitMaskTo_p_SoField, 0, 0},  {&_swigt__p_SoMFBool, _p_SoMFBoolTo_p_SoField, 0, 0},  {&_swigt__p_SoMFColor, _p_SoMFColorTo_p_SoField, 0, 0},  {&_swigt__p_SoMFColorRGBA, _p_SoMFColorRGBATo_p_SoField, 0, 0},  {&_swigt__p_SoMFDouble, _p_SoMFDoubleTo_p_SoField, 0, 0},  {&_swigt__p_SoMFEngine, _p_SoMFEngineTo_p_SoField, 0, 0},  {&_swigt__p_SoMFEnum, _p_SoMFEnumTo_p_SoField, 0, 0},  {&_swigt__p_SoMFFloat, _p_SoMFFloatTo_p_SoField, 0, 0},  {&_swigt__p_SoMFInt32, _p_SoMFInt32To_p_SoField, 0, 0},  {&_swigt__p_SoMFMatrix, _p_SoMFMatrixTo_p_SoField, 0, 0},  {&_swigt__p_SoMFName, _p_SoMFNameTo_p_SoField, 0, 0},  {&_swigt__p_SoMFNode, _p_SoMFNodeTo_p_SoField, 0, 0},  {&_swigt__p_SoMFPath, _p_SoMFPathTo_p_SoField, 0, 0},  {&_swigt__p_SoMFPlane, _p_SoMFPlaneTo_p_SoField, 0, 0},  {&_swigt__p_SoMFRotation, _p_SoMFRotationTo_p_SoField, 0, 0},  {&_swigt__p_SoMFShort, _p_SoMFShortTo_p_SoField, 0, 0},  {&_swigt__p_SoMFString, _p_SoMFStringTo_p_SoField, 0, 0},  {&_swigt__p_SoMFTime, _p_SoMFTimeTo_p_SoField, 0, 0},  {&_swigt__p_SoMFUInt32, _p_SoMFUInt32To_p_SoField, 0, 0},  {&_swigt__p_SoMFUShort, _p_SoMFUShortTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec2b, _p_SoMFVec2bTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec2d, _p_SoMFVec2dTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec2f, _p_SoMFVec2fTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec2i32, _p_SoMFVec2i32To_p_SoField, 0, 0},  {&_swigt__p_SoMFVec2s, _p_SoMFVec2sTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec3b, _p_SoMFVec3bTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec3d, _p_SoMFVec3dTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec3f, _p_SoMFVec3fTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec3i32, _p_SoMFVec3i32To_p_SoField, 0, 0},  {&_swigt__p_SoMFVec3s, _p_SoMFVec3sTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4b, _p_SoMFVec4bTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4d, _p_SoMFVec4dTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4f, _p_SoMFVec4fTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4i32, _p_SoMFVec4i32To_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4s, _p_SoMFVec4sTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4ub, _p_SoMFVec4ubTo_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4ui32, _p_SoMFVec4ui32To_p_SoField, 0, 0},  {&_swigt__p_SoMFVec4us, _p_SoMFVec4usTo_p_SoField, 0, 0},  {&_swigt__p_SoMField, _p_SoMFieldTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBitMask, _p_SoSFBitMaskTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBool, _p_SoSFBoolTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox2d, _p_SoSFBox2dTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox2f, _p_SoSFBox2fTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox2i32, _p_SoSFBox2i32To_p_SoField, 0, 0},  {&_swigt__p_SoSFBox2s, _p_SoSFBox2sTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox3d, _p_SoSFBox3dTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox3f, _p_SoSFBox3fTo_p_SoField, 0, 0},  {&_swigt__p_SoSFBox3i32, _p_SoSFBox3i32To_p_SoField, 0, 0},  {&_swigt__p_SoSFBox3s, _p_SoSFBox3sTo_p_SoField, 0, 0},  {&_swigt__p_SoSFColor, _p_SoSFColorTo_p_SoField, 0, 0},  {&_swigt__p_SoSFColorRGBA, _p_SoSFColorRGBATo_p_SoField, 0, 0},  {&_swigt__p_SoSFDouble, _p_SoSFDoubleTo_p_SoField, 0, 0},  {&_swigt__p_SoSFEngine, _p_SoSFEngineTo_p_SoField, 0, 0},  {&_swigt__p_SoSFEnum, _p_SoSFEnumTo_p_SoField, 0, 0},  {&_swigt__p_SoSFFloat, _p_SoSFFloatTo_p_SoField, 0, 0},  {&_swigt__p_SoSFImage, _p_SoSFImageTo_p_SoField, 0, 0},  {&_swigt__p_SoSFImage3, _p_SoSFImage3To_p_SoField, 0, 0},  {&_swigt__p_SoSFInt32, _p_SoSFInt32To_p_SoField, 0, 0},  {&_swigt__p_SoSFMatrix, _p_SoSFMatrixTo_p_SoField, 0, 0},  {&_swigt__p_SoSFName, _p_SoSFNameTo_p_SoField, 0, 0},  {&_swigt__p_SoSFNode, _p_SoSFNodeTo_p_SoField, 0, 0},  {&_swigt__p_SoSFPath, _p_SoSFPathTo_p_SoField, 0, 0},  {&_swigt__p_SoSFPlane, _p_SoSFPlaneTo_p_SoField, 0, 0},  {&_swigt__p_SoSFRotation, _p_SoSFRotationTo_p_SoField, 0, 0},  {&_swigt__p_SoSFShort, _p_SoSFShortTo_p_SoField, 0, 0},  {&_swigt__p_SoSFString, _p_SoSFStringTo_p_SoField, 0, 0},  {&_swigt__p_SoSFTime, _p_SoSFTimeTo_p_SoField, 0, 0},  {&_swigt__p_SoSFTrigger, _p_SoSFTriggerTo_p_SoField, 0, 0},  {&_swigt__p_SoSFUInt32, _p_SoSFUInt32To_p_SoField, 0, 0},  {&_swigt__p_SoSFUShort, _p_SoSFUShortTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec2b, _p_SoSFVec2bTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec2d, _p_SoSFVec2dTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec2f, _p_SoSFVec2fTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec2i32, _p_SoSFVec2i32To_p_SoField, 0, 0},  {&_swigt__p_SoSFVec2s, _p_SoSFVec2sTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec3b, _p_SoSFVec3bTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec3d, _p_SoSFVec3dTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec3f, _p_SoSFVec3fTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec3i32, _p_SoSFVec3i32To_p_SoField, 0, 0},  {&_swigt__p_SoSFVec3s, _p_SoSFVec3sTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4b, _p_SoSFVec4bTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4d, _p_SoSFVec4dTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4f, _p_SoSFVec4fTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4i32, _p_SoSFVec4i32To_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4s, _p_SoSFVec4sTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4ub, _p_SoSFVec4ubTo_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4ui32, _p_SoSFVec4ui32To_p_SoField, 0, 0},  {&_swigt__p_SoSFVec4us, _p_SoSFVec4usTo_p_SoField, 0, 0},  {&_swigt__p_SoSField, _p_SoSFieldTo_p_SoField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFieldContainer[] = {  {&_swigt__p_SoFieldContainer, 0, 0, 0},  {&_swigt__p_SoAlphaTest, _p_SoAlphaTestTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoAnnotation, _p_SoAnnotationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoAntiSquish, _p_SoAntiSquishTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoAppearanceKit, _p_SoAppearanceKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoArray, _p_SoArrayTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoAsciiText, _p_SoAsciiTextTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBaseColor, _p_SoBaseColorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBaseKit, _p_SoBaseKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBlinker, _p_SoBlinkerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBoolOperation, _p_SoBoolOperationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBumpMap, _p_SoBumpMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBumpMapCoordinate, _p_SoBumpMapCoordinateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoBumpMapTransform, _p_SoBumpMapTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCacheHint, _p_SoCacheHintTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCalculator, _p_SoCalculatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCallback, _p_SoCallbackTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCamera, _p_SoCameraTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCameraKit, _p_SoCameraKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoClipPlane, _p_SoClipPlaneTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoClipPlaneManip, _p_SoClipPlaneManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoColorIndex, _p_SoColorIndexTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComplexity, _p_SoComplexityTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeMatrix, _p_SoComposeMatrixTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeRotation, _p_SoComposeRotationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeRotationFromTo, _p_SoComposeRotationFromToTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeVec2f, _p_SoComposeVec2fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeVec3f, _p_SoComposeVec3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComposeVec4f, _p_SoComposeVec4fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoComputeBoundingBox, _p_SoComputeBoundingBoxTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoConcatenate, _p_SoConcatenateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCone, _p_SoConeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCoordinate3, _p_SoCoordinate3To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCoordinate4, _p_SoCoordinate4To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCounter, _p_SoCounterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCube, _p_SoCubeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoCylinder, _p_SoCylinderTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDecomposeMatrix, _p_SoDecomposeMatrixTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDecomposeRotation, _p_SoDecomposeRotationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDecomposeVec2f, _p_SoDecomposeVec2fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDecomposeVec3f, _p_SoDecomposeVec3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDecomposeVec4f, _p_SoDecomposeVec4fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDepthBuffer, _p_SoDepthBufferTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDirectionalLight, _p_SoDirectionalLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDirectionalLightManip, _p_SoDirectionalLightManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDragger, _p_SoDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoDrawStyle, _p_SoDrawStyleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoElapsedTime, _p_SoElapsedTimeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoEngine, _p_SoEngineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoEnvironment, _p_SoEnvironmentTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoEventCallback, _p_SoEventCallbackTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFieldConverter, _p_SoFieldConverterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFile, _p_SoFileTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFont, _p_SoFontTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFontStyle, _p_SoFontStyleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFragmentShader, _p_SoFragmentShaderTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoFrustumCamera, _p_SoFrustumCameraTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGate, _p_SoGateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGeoCoordinate, _p_SoGeoCoordinateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGeoLocation, _p_SoGeoLocationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGeoOrigin, _p_SoGeoOriginTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGeoSeparator, _p_SoGeoSeparatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoGroup, _p_SoGroupTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoHeightMapToNormalMap, _p_SoHeightMapToNormalMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoImage, _p_SoImageTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedNurbsCurve, _p_SoIndexedNurbsCurveTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedNurbsSurface, _p_SoIndexedNurbsSurfaceTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedShape, _p_SoIndexedShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInfo, _p_SoInfoTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInteractionKit, _p_SoInteractionKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolate, _p_SoInterpolateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolateFloat, _p_SoInterpolateFloatTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolateRotation, _p_SoInterpolateRotationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolateVec2f, _p_SoInterpolateVec2fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolateVec3f, _p_SoInterpolateVec3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoInterpolateVec4f, _p_SoInterpolateVec4fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLOD, _p_SoLODTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLabel, _p_SoLabelTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLevelOfDetail, _p_SoLevelOfDetailTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLight, _p_SoLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLightKit, _p_SoLightKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLightModel, _p_SoLightModelTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLinearProfile, _p_SoLinearProfileTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoListener, _p_SoListenerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoLocateHighlight, _p_SoLocateHighlightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoMaterial, _p_SoMaterialTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoMaterialBinding, _p_SoMaterialBindingTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoMatrixTransform, _p_SoMatrixTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoMultipleCopy, _p_SoMultipleCopyTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNode, _p_SoNodeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNodeEngine, _p_SoNodeEngineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNodeKitListPart, _p_SoNodeKitListPartTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNonIndexedShape, _p_SoNonIndexedShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNormal, _p_SoNormalTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNormalBinding, _p_SoNormalBindingTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNurbsCurve, _p_SoNurbsCurveTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNurbsProfile, _p_SoNurbsProfileTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoNurbsSurface, _p_SoNurbsSurfaceTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoOnOff, _p_SoOnOffTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoOneShot, _p_SoOneShotTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoOrthographicCamera, _p_SoOrthographicCameraTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPackedColor, _p_SoPackedColorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPathSwitch, _p_SoPathSwitchTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPendulum, _p_SoPendulumTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPerspectiveCamera, _p_SoPerspectiveCameraTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPickStyle, _p_SoPickStyleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPointLight, _p_SoPointLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPointLightManip, _p_SoPointLightManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoPolygonOffset, _p_SoPolygonOffsetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoProfile, _p_SoProfileTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoProfileCoordinate2, _p_SoProfileCoordinate2To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoProfileCoordinate3, _p_SoProfileCoordinate3To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoProto, _p_SoProtoTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoProtoInstance, _p_SoProtoInstanceTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoResetTransform, _p_SoResetTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoReversePerspectiveCamera, _p_SoReversePerspectiveCameraTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotation, _p_SoRotationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotationXYZ, _p_SoRotationXYZTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoRotor, _p_SoRotorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoScale, _p_SoScaleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSceneKit, _p_SoSceneKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSceneTexture2, _p_SoSceneTexture2To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSceneTextureCubeMap, _p_SoSceneTextureCubeMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSelectOne, _p_SoSelectOneTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSelection, _p_SoSelectionTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSeparator, _p_SoSeparatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSeparatorKit, _p_SoSeparatorKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderObject, _p_SoShaderObjectTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter, _p_SoShaderParameterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter1f, _p_SoShaderParameter1fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter1i, _p_SoShaderParameter1iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter2f, _p_SoShaderParameter2fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter2i, _p_SoShaderParameter2iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter3f, _p_SoShaderParameter3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter3i, _p_SoShaderParameter3iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter4f, _p_SoShaderParameter4fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameter4i, _p_SoShaderParameter4iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray1f, _p_SoShaderParameterArray1fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray1i, _p_SoShaderParameterArray1iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray2f, _p_SoShaderParameterArray2fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray2i, _p_SoShaderParameterArray2iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray3f, _p_SoShaderParameterArray3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray3i, _p_SoShaderParameterArray3iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray4f, _p_SoShaderParameterArray4fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterArray4i, _p_SoShaderParameterArray4iTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterMatrix, _p_SoShaderParameterMatrixTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderParameterMatrixArray, _p_SoShaderParameterMatrixArrayTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderProgram, _p_SoShaderProgramTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShaderStateMatrixParameter, _p_SoShaderStateMatrixParameterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShape, _p_SoShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShapeHints, _p_SoShapeHintsTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShapeKit, _p_SoShapeKitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoShuttle, _p_SoShuttleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSphere, _p_SoSphereTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSpotLight, _p_SoSpotLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSpotLightManip, _p_SoSpotLightManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSurroundScale, _p_SoSurroundScaleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoSwitch, _p_SoSwitchTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoText2, _p_SoText2To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoText3, _p_SoText3To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture, _p_SoTextureTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture2, _p_SoTexture2To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture2Convert, _p_SoTexture2ConvertTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture2Transform, _p_SoTexture2TransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture3, _p_SoTexture3To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTexture3Transform, _p_SoTexture3TransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCombine, _p_SoTextureCombineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinate2, _p_SoTextureCoordinate2To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinate3, _p_SoTextureCoordinate3To_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateBinding, _p_SoTextureCoordinateBindingTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateCube, _p_SoTextureCoordinateCubeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateCylinder, _p_SoTextureCoordinateCylinderTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateDefault, _p_SoTextureCoordinateDefaultTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateEnvironment, _p_SoTextureCoordinateEnvironmentTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateFunction, _p_SoTextureCoordinateFunctionTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateNormalMap, _p_SoTextureCoordinateNormalMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateObject, _p_SoTextureCoordinateObjectTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinatePlane, _p_SoTextureCoordinatePlaneTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateReflectionMap, _p_SoTextureCoordinateReflectionMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCoordinateSphere, _p_SoTextureCoordinateSphereTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureCubeMap, _p_SoTextureCubeMapTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureMatrixTransform, _p_SoTextureMatrixTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureScalePolicy, _p_SoTextureScalePolicyTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTextureUnit, _p_SoTextureUnitTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTimeCounter, _p_SoTimeCounterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransform, _p_SoTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformManip, _p_SoTransformManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformSeparator, _p_SoTransformSeparatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformVec3f, _p_SoTransformVec3fTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformation, _p_SoTransformationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTranslation, _p_SoTranslationTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTransparencyType, _p_SoTransparencyTypeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoTriggerAny, _p_SoTriggerAnyTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoUniformShaderParameter, _p_SoUniformShaderParameterTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoUnits, _p_SoUnitsTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLAnchor, _p_SoVRMLAnchorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLAppearance, _p_SoVRMLAppearanceTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLAudioClip, _p_SoVRMLAudioClipTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLBackground, _p_SoVRMLBackgroundTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLBillboard, _p_SoVRMLBillboardTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLBox, _p_SoVRMLBoxTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLColor, _p_SoVRMLColorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLColorInterpolator, _p_SoVRMLColorInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCone, _p_SoVRMLConeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCoordinate, _p_SoVRMLCoordinateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCoordinateInterpolator, _p_SoVRMLCoordinateInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCylinder, _p_SoVRMLCylinderTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLCylinderSensor, _p_SoVRMLCylinderSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLDirectionalLight, _p_SoVRMLDirectionalLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLDragSensor, _p_SoVRMLDragSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLElevationGrid, _p_SoVRMLElevationGridTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLExtrusion, _p_SoVRMLExtrusionTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLFog, _p_SoVRMLFogTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLFontStyle, _p_SoVRMLFontStyleTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLGeometry, _p_SoVRMLGeometryTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLGroup, _p_SoVRMLGroupTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLImageTexture, _p_SoVRMLImageTextureTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLInline, _p_SoVRMLInlineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLInterpolator, _p_SoVRMLInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLLOD, _p_SoVRMLLODTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLLight, _p_SoVRMLLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLMaterial, _p_SoVRMLMaterialTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLMovieTexture, _p_SoVRMLMovieTextureTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLNavigationInfo, _p_SoVRMLNavigationInfoTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLNormal, _p_SoVRMLNormalTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLNormalInterpolator, _p_SoVRMLNormalInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLOrientationInterpolator, _p_SoVRMLOrientationInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLParent, _p_SoVRMLParentTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLPixelTexture, _p_SoVRMLPixelTextureTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLPlaneSensor, _p_SoVRMLPlaneSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLPointLight, _p_SoVRMLPointLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLPositionInterpolator, _p_SoVRMLPositionInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLProximitySensor, _p_SoVRMLProximitySensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLScalarInterpolator, _p_SoVRMLScalarInterpolatorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLScript, _p_SoVRMLScriptTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSensor, _p_SoVRMLSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLShape, _p_SoVRMLShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSound, _p_SoVRMLSoundTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSphere, _p_SoVRMLSphereTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSphereSensor, _p_SoVRMLSphereSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSpotLight, _p_SoVRMLSpotLightTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLSwitch, _p_SoVRMLSwitchTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLText, _p_SoVRMLTextTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTexture, _p_SoVRMLTextureTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTextureCoordinate, _p_SoVRMLTextureCoordinateTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTextureTransform, _p_SoVRMLTextureTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTimeSensor, _p_SoVRMLTimeSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTouchSensor, _p_SoVRMLTouchSensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLVertexLine, _p_SoVRMLVertexLineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLVertexPoint, _p_SoVRMLVertexPointTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLVertexShape, _p_SoVRMLVertexShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLViewpoint, _p_SoVRMLViewpointTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLVisibilitySensor, _p_SoVRMLVisibilitySensorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVRMLWorldInfo, _p_SoVRMLWorldInfoTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVertexAttribute, _p_SoVertexAttributeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVertexAttributeBinding, _p_SoVertexAttributeBindingTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVertexProperty, _p_SoVertexPropertyTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVertexShader, _p_SoVertexShaderTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoVertexShape, _p_SoVertexShapeTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoWWWInline, _p_SoWWWInlineTo_p_SoFieldContainer, 0, 0},  {&_swigt__p_SoWrapperKit, _p_SoWrapperKitTo_p_SoFieldContainer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFieldConverter[] = {  {&_swigt__p_SoFieldConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFieldData[] = {  {&_swigt__p_SoFieldData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFieldList[] = {  {&_swigt__p_SoFieldList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFieldSensor[] = {  {&_swigt__p_SoFieldSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFile[] = {  {&_swigt__p_SoFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFloatElement[] = {  {&_swigt__p_SoFloatElement, 0, 0, 0},  {&_swigt__p_SoComplexityElement, _p_SoComplexityElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoCreaseAngleElement, _p_SoCreaseAngleElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoDecimationPercentageElement, _p_SoDecimationPercentageElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoFocalDistanceElement, _p_SoFocalDistanceElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoFontSizeElement, _p_SoFontSizeElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoGLLineWidthElement, _p_SoGLLineWidthElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoGLPointSizeElement, _p_SoGLPointSizeElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoLineWidthElement, _p_SoLineWidthElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoListenerGainElement, _p_SoListenerGainElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoPointSizeElement, _p_SoPointSizeElementTo_p_SoFloatElement, 0, 0},  {&_swigt__p_SoTextureQualityElement, _p_SoTextureQualityElementTo_p_SoFloatElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFocalDistanceElement[] = {  {&_swigt__p_SoFocalDistanceElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFont[] = {  {&_swigt__p_SoFont, 0, 0, 0},  {&_swigt__p_SoFontStyle, _p_SoFontStyleTo_p_SoFont, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFontNameElement[] = {  {&_swigt__p_SoFontNameElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFontSizeElement[] = {  {&_swigt__p_SoFontSizeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFontStyle[] = {  {&_swigt__p_SoFontStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFragmentShader[] = {  {&_swigt__p_SoFragmentShader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFrustumCamera[] = {  {&_swigt__p_SoFrustumCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFullPath[] = {  {&_swigt__p_SoFullPath, 0, 0, 0},  {&_swigt__p_SoTempPath, _p_SoTempPathTo_p_SoFullPath, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLBigImage[] = {  {&_swigt__p_SoGLBigImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLCacheContextElement[] = {  {&_swigt__p_SoGLCacheContextElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLCacheList[] = {  {&_swigt__p_SoGLCacheList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLClipPlaneElement[] = {  {&_swigt__p_SoGLClipPlaneElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLColorIndexElement[] = {  {&_swigt__p_SoGLColorIndexElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLCoordinateElement[] = {  {&_swigt__p_SoGLCoordinateElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLDepthBufferElement[] = {  {&_swigt__p_SoGLDepthBufferElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLDisplayList[] = {  {&_swigt__p_SoGLDisplayList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLDrawStyleElement[] = {  {&_swigt__p_SoGLDrawStyleElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLEnvironmentElement[] = {  {&_swigt__p_SoGLEnvironmentElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLImage[] = {  {&_swigt__p_SoGLImage, 0, 0, 0},  {&_swigt__p_SoGLBigImage, _p_SoGLBigImageTo_p_SoGLImage, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLImageResizeCB[] = {  {&_swigt__p_SoGLImageResizeCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLLazyElement[] = {  {&_swigt__p_SoGLLazyElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLLazyElement__GLState[] = {  {&_swigt__p_SoGLLazyElement__GLState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLLightIdElement[] = {  {&_swigt__p_SoGLLightIdElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLLinePatternElement[] = {  {&_swigt__p_SoGLLinePatternElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLLineWidthElement[] = {  {&_swigt__p_SoGLLineWidthElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLModelMatrixElement[] = {  {&_swigt__p_SoGLModelMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLMultiTextureCoordinateElement[] = {  {&_swigt__p_SoGLMultiTextureCoordinateElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLMultiTextureEnabledElement[] = {  {&_swigt__p_SoGLMultiTextureEnabledElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLMultiTextureImageElement[] = {  {&_swigt__p_SoGLMultiTextureImageElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLMultiTextureMatrixElement[] = {  {&_swigt__p_SoGLMultiTextureMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLNormalElement[] = {  {&_swigt__p_SoGLNormalElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLPointSizeElement[] = {  {&_swigt__p_SoGLPointSizeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLPolygonOffsetElement[] = {  {&_swigt__p_SoGLPolygonOffsetElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLProjectionMatrixElement[] = {  {&_swigt__p_SoGLProjectionMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLRenderAbortCB[] = {  {&_swigt__p_SoGLRenderAbortCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLRenderAction[] = {  {&_swigt__p_SoGLRenderAction, 0, 0, 0},  {&_swigt__p_SoBoxHighlightRenderAction, _p_SoBoxHighlightRenderActionTo_p_SoGLRenderAction, 0, 0},  {&_swigt__p_SoLineHighlightRenderAction, _p_SoLineHighlightRenderActionTo_p_SoGLRenderAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLRenderCache[] = {  {&_swigt__p_SoGLRenderCache, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLRenderPassElement[] = {  {&_swigt__p_SoGLRenderPassElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLShaderObject[] = {  {&_swigt__p_SoGLShaderObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLShapeHintsElement[] = {  {&_swigt__p_SoGLShapeHintsElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLUpdateAreaElement[] = {  {&_swigt__p_SoGLUpdateAreaElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLVBOElement[] = {  {&_swigt__p_SoGLVBOElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLVertexAttributeElement[] = {  {&_swigt__p_SoGLVertexAttributeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLViewingMatrixElement[] = {  {&_swigt__p_SoGLViewingMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGLViewportRegionElement[] = {  {&_swigt__p_SoGLViewportRegionElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGate[] = {  {&_swigt__p_SoGate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGeo[] = {  {&_swigt__p_SoGeo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGeoCoordinate[] = {  {&_swigt__p_SoGeoCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGeoLocation[] = {  {&_swigt__p_SoGeoLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGeoOrigin[] = {  {&_swigt__p_SoGeoOrigin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGeoSeparator[] = {  {&_swigt__p_SoGeoSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGetBoundingBoxAction[] = {  {&_swigt__p_SoGetBoundingBoxAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGetMatrixAction[] = {  {&_swigt__p_SoGetMatrixAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGetPrimitiveCountAction[] = {  {&_swigt__p_SoGetPrimitiveCountAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGlyph[] = {  {&_swigt__p_SoGlyph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoGroup[] = {  {&_swigt__p_SoGroup, 0, 0, 0},  {&_swigt__p_SoAnnotation, _p_SoAnnotationTo_p_SoGroup, 0, 0},  {&_swigt__p_SoArray, _p_SoArrayTo_p_SoGroup, 0, 0},  {&_swigt__p_SoBlinker, _p_SoBlinkerTo_p_SoGroup, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoGroup, 0, 0},  {&_swigt__p_SoGeoSeparator, _p_SoGeoSeparatorTo_p_SoGroup, 0, 0},  {&_swigt__p_SoLOD, _p_SoLODTo_p_SoGroup, 0, 0},  {&_swigt__p_SoLevelOfDetail, _p_SoLevelOfDetailTo_p_SoGroup, 0, 0},  {&_swigt__p_SoLocateHighlight, _p_SoLocateHighlightTo_p_SoGroup, 0, 0},  {&_swigt__p_SoMultipleCopy, _p_SoMultipleCopyTo_p_SoGroup, 0, 0},  {&_swigt__p_SoPathSwitch, _p_SoPathSwitchTo_p_SoGroup, 0, 0},  {&_swigt__p_SoSelection, _p_SoSelectionTo_p_SoGroup, 0, 0},  {&_swigt__p_SoSeparator, _p_SoSeparatorTo_p_SoGroup, 0, 0},  {&_swigt__p_SoSwitch, _p_SoSwitchTo_p_SoGroup, 0, 0},  {&_swigt__p_SoTransformSeparator, _p_SoTransformSeparatorTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLAnchor, _p_SoVRMLAnchorTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLBillboard, _p_SoVRMLBillboardTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLGroup, _p_SoVRMLGroupTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLLOD, _p_SoVRMLLODTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLParent, _p_SoVRMLParentTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLSwitch, _p_SoVRMLSwitchTo_p_SoGroup, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoGroup, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoGroup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoHandleBoxDragger[] = {  {&_swigt__p_SoHandleBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoHandleBoxManip[] = {  {&_swigt__p_SoHandleBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoHandleEventAction[] = {  {&_swigt__p_SoHandleEventAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoHardCopy[] = {  {&_swigt__p_SoHardCopy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoHeightMapToNormalMap[] = {  {&_swigt__p_SoHeightMapToNormalMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIdleSensor[] = {  {&_swigt__p_SoIdleSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoImage[] = {  {&_swigt__p_SoImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedFaceSet[] = {  {&_swigt__p_SoIndexedFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedLineSet[] = {  {&_swigt__p_SoIndexedLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedMarkerSet[] = {  {&_swigt__p_SoIndexedMarkerSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedNurbsCurve[] = {  {&_swigt__p_SoIndexedNurbsCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedNurbsSurface[] = {  {&_swigt__p_SoIndexedNurbsSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedPointSet[] = {  {&_swigt__p_SoIndexedPointSet, 0, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoIndexedPointSet, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedShape[] = {  {&_swigt__p_SoIndexedShape, 0, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoIndexedShape, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoIndexedShape, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoIndexedShape, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoIndexedShape, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoIndexedShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedTriangleStripSet[] = {  {&_swigt__p_SoIndexedTriangleStripSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInfo[] = {  {&_swigt__p_SoInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInput[] = {  {&_swigt__p_SoInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInt32Element[] = {  {&_swigt__p_SoInt32Element, 0, 0, 0},  {&_swigt__p_SoAnnoText3CharOrientElement, _p_SoAnnoText3CharOrientElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoAnnoText3FontSizeHintElement, _p_SoAnnoText3FontSizeHintElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoAnnoText3RenderPrintElement, _p_SoAnnoText3RenderPrintElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoComplexityTypeElement, _p_SoComplexityTypeElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoDecimationTypeElement, _p_SoDecimationTypeElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoDrawStyleElement, _p_SoDrawStyleElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoGLDrawStyleElement, _p_SoGLDrawStyleElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoGLLightIdElement, _p_SoGLLightIdElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoGLLinePatternElement, _p_SoGLLinePatternElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoLightModelElement, _p_SoLightModelElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoLinePatternElement, _p_SoLinePatternElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoMaterialBindingElement, _p_SoMaterialBindingElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoNormalBindingElement, _p_SoNormalBindingElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoPickStyleElement, _p_SoPickStyleElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoSwitchElement, _p_SoSwitchElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoTextOutlineEnabledElement, _p_SoTextOutlineEnabledElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoTextureCoordinateBindingElement, _p_SoTextureCoordinateBindingElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoTextureUnitElement, _p_SoTextureUnitElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoUnitsElement, _p_SoUnitsElementTo_p_SoInt32Element, 0, 0},  {&_swigt__p_SoVertexAttributeBindingElement, _p_SoVertexAttributeBindingElementTo_p_SoInt32Element, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInteraction[] = {  {&_swigt__p_SoInteraction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInteractionKit[] = {  {&_swigt__p_SoInteractionKit, 0, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoDragger, _p_SoDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoInteractionKit, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoInteractionKit, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolate[] = {  {&_swigt__p_SoInterpolate, 0, 0, 0},  {&_swigt__p_SoInterpolateFloat, _p_SoInterpolateFloatTo_p_SoInterpolate, 0, 0},  {&_swigt__p_SoInterpolateRotation, _p_SoInterpolateRotationTo_p_SoInterpolate, 0, 0},  {&_swigt__p_SoInterpolateVec2f, _p_SoInterpolateVec2fTo_p_SoInterpolate, 0, 0},  {&_swigt__p_SoInterpolateVec3f, _p_SoInterpolateVec3fTo_p_SoInterpolate, 0, 0},  {&_swigt__p_SoInterpolateVec4f, _p_SoInterpolateVec4fTo_p_SoInterpolate, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolateFloat[] = {  {&_swigt__p_SoInterpolateFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolateRotation[] = {  {&_swigt__p_SoInterpolateRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolateVec2f[] = {  {&_swigt__p_SoInterpolateVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolateVec3f[] = {  {&_swigt__p_SoInterpolateVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolateVec4f[] = {  {&_swigt__p_SoInterpolateVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIntersectingPrimitive[] = {  {&_swigt__p_SoIntersectingPrimitive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIntersectionCB[] = {  {&_swigt__p_SoIntersectionCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIntersectionDetectionAction[] = {  {&_swigt__p_SoIntersectionDetectionAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIntersectionFilterCB[] = {  {&_swigt__p_SoIntersectionFilterCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIntersectionVisitationCB[] = {  {&_swigt__p_SoIntersectionVisitationCB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoJackDragger[] = {  {&_swigt__p_SoJackDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoJackManip[] = {  {&_swigt__p_SoJackManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoKeyboardEvent[] = {  {&_swigt__p_SoKeyboardEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLOD[] = {  {&_swigt__p_SoLOD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLabel[] = {  {&_swigt__p_SoLabel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLazyElement[] = {  {&_swigt__p_SoLazyElement, 0, 0, 0},  {&_swigt__p_SoGLLazyElement, _p_SoGLLazyElementTo_p_SoLazyElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLevelOfDetail[] = {  {&_swigt__p_SoLevelOfDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLight[] = {  {&_swigt__p_SoLight, 0, 0, 0},  {&_swigt__p_SoDirectionalLight, _p_SoDirectionalLightTo_p_SoLight, 0, 0},  {&_swigt__p_SoDirectionalLightManip, _p_SoDirectionalLightManipTo_p_SoLight, 0, 0},  {&_swigt__p_SoPointLight, _p_SoPointLightTo_p_SoLight, 0, 0},  {&_swigt__p_SoPointLightManip, _p_SoPointLightManipTo_p_SoLight, 0, 0},  {&_swigt__p_SoSpotLight, _p_SoSpotLightTo_p_SoLight, 0, 0},  {&_swigt__p_SoSpotLightManip, _p_SoSpotLightManipTo_p_SoLight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightAttenuationElement[] = {  {&_swigt__p_SoLightAttenuationElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightElement[] = {  {&_swigt__p_SoLightElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightKit[] = {  {&_swigt__p_SoLightKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightModel[] = {  {&_swigt__p_SoLightModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightModelElement[] = {  {&_swigt__p_SoLightModelElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLightPath[] = {  {&_swigt__p_SoLightPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLineDetail[] = {  {&_swigt__p_SoLineDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLineHighlightRenderAction[] = {  {&_swigt__p_SoLineHighlightRenderAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLinePatternElement[] = {  {&_swigt__p_SoLinePatternElement, 0, 0, 0},  {&_swigt__p_SoGLLinePatternElement, _p_SoGLLinePatternElementTo_p_SoLinePatternElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLineSet[] = {  {&_swigt__p_SoLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLineWidthElement[] = {  {&_swigt__p_SoLineWidthElement, 0, 0, 0},  {&_swigt__p_SoGLLineWidthElement, _p_SoGLLineWidthElementTo_p_SoLineWidthElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLinearProfile[] = {  {&_swigt__p_SoLinearProfile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoListener[] = {  {&_swigt__p_SoListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoListenerDopplerElement[] = {  {&_swigt__p_SoListenerDopplerElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoListenerGainElement[] = {  {&_swigt__p_SoListenerGainElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoListenerOrientationElement[] = {  {&_swigt__p_SoListenerOrientationElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoListenerPositionElement[] = {  {&_swigt__p_SoListenerPositionElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLocalBBoxMatrixElement[] = {  {&_swigt__p_SoLocalBBoxMatrixElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLocateHighlight[] = {  {&_swigt__p_SoLocateHighlight, 0, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoLocateHighlight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLocation2Event[] = {  {&_swigt__p_SoLocation2Event, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLockManager[] = {  {&_swigt__p_SoLockManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFBitMask[] = {  {&_swigt__p_SoMFBitMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFBool[] = {  {&_swigt__p_SoMFBool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFColor[] = {  {&_swigt__p_SoMFColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFColorRGBA[] = {  {&_swigt__p_SoMFColorRGBA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFDouble[] = {  {&_swigt__p_SoMFDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFEngine[] = {  {&_swigt__p_SoMFEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFEnum[] = {  {&_swigt__p_SoMFEnum, 0, 0, 0},  {&_swigt__p_SoMFBitMask, _p_SoMFBitMaskTo_p_SoMFEnum, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFFloat[] = {  {&_swigt__p_SoMFFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFInt32[] = {  {&_swigt__p_SoMFInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFMatrix[] = {  {&_swigt__p_SoMFMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFName[] = {  {&_swigt__p_SoMFName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFNode[] = {  {&_swigt__p_SoMFNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFPath[] = {  {&_swigt__p_SoMFPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFPlane[] = {  {&_swigt__p_SoMFPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFRotation[] = {  {&_swigt__p_SoMFRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFShort[] = {  {&_swigt__p_SoMFShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFString[] = {  {&_swigt__p_SoMFString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFTime[] = {  {&_swigt__p_SoMFTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFUInt32[] = {  {&_swigt__p_SoMFUInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFUShort[] = {  {&_swigt__p_SoMFUShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec2b[] = {  {&_swigt__p_SoMFVec2b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec2d[] = {  {&_swigt__p_SoMFVec2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec2f[] = {  {&_swigt__p_SoMFVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec2i32[] = {  {&_swigt__p_SoMFVec2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec2s[] = {  {&_swigt__p_SoMFVec2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec3b[] = {  {&_swigt__p_SoMFVec3b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec3d[] = {  {&_swigt__p_SoMFVec3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec3f[] = {  {&_swigt__p_SoMFVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec3i32[] = {  {&_swigt__p_SoMFVec3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec3s[] = {  {&_swigt__p_SoMFVec3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4b[] = {  {&_swigt__p_SoMFVec4b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4d[] = {  {&_swigt__p_SoMFVec4d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4f[] = {  {&_swigt__p_SoMFVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4i32[] = {  {&_swigt__p_SoMFVec4i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4s[] = {  {&_swigt__p_SoMFVec4s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4ub[] = {  {&_swigt__p_SoMFVec4ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4ui32[] = {  {&_swigt__p_SoMFVec4ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMFVec4us[] = {  {&_swigt__p_SoMFVec4us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMField[] = {  {&_swigt__p_SoMField, 0, 0, 0},  {&_swigt__p_SoMFBitMask, _p_SoMFBitMaskTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFBool, _p_SoMFBoolTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFColor, _p_SoMFColorTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFColorRGBA, _p_SoMFColorRGBATo_p_SoMField, 0, 0},  {&_swigt__p_SoMFDouble, _p_SoMFDoubleTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFEngine, _p_SoMFEngineTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFEnum, _p_SoMFEnumTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFFloat, _p_SoMFFloatTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFInt32, _p_SoMFInt32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFMatrix, _p_SoMFMatrixTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFName, _p_SoMFNameTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFNode, _p_SoMFNodeTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFPath, _p_SoMFPathTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFPlane, _p_SoMFPlaneTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFRotation, _p_SoMFRotationTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFShort, _p_SoMFShortTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFString, _p_SoMFStringTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFTime, _p_SoMFTimeTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFUInt32, _p_SoMFUInt32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFUShort, _p_SoMFUShortTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec2b, _p_SoMFVec2bTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec2d, _p_SoMFVec2dTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec2f, _p_SoMFVec2fTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec2i32, _p_SoMFVec2i32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec2s, _p_SoMFVec2sTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec3b, _p_SoMFVec3bTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec3d, _p_SoMFVec3dTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec3f, _p_SoMFVec3fTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec3i32, _p_SoMFVec3i32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec3s, _p_SoMFVec3sTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4b, _p_SoMFVec4bTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4d, _p_SoMFVec4dTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4f, _p_SoMFVec4fTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4i32, _p_SoMFVec4i32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4s, _p_SoMFVec4sTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4ub, _p_SoMFVec4ubTo_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4ui32, _p_SoMFVec4ui32To_p_SoMField, 0, 0},  {&_swigt__p_SoMFVec4us, _p_SoMFVec4usTo_p_SoMField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMarkerSet[] = {  {&_swigt__p_SoMarkerSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMaterial[] = {  {&_swigt__p_SoMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMaterialBinding[] = {  {&_swigt__p_SoMaterialBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMaterialBindingElement[] = {  {&_swigt__p_SoMaterialBindingElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMaterialBundle[] = {  {&_swigt__p_SoMaterialBundle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMatrixTransform[] = {  {&_swigt__p_SoMatrixTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMemoryError[] = {  {&_swigt__p_SoMemoryError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoModelMatrixElement[] = {  {&_swigt__p_SoModelMatrixElement, 0, 0, 0},  {&_swigt__p_SoBBoxModelMatrixElement, _p_SoBBoxModelMatrixElementTo_p_SoModelMatrixElement, 0, 0},  {&_swigt__p_SoGLModelMatrixElement, _p_SoGLModelMatrixElementTo_p_SoModelMatrixElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMotion3Event[] = {  {&_swigt__p_SoMotion3Event, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMouseButtonEvent[] = {  {&_swigt__p_SoMouseButtonEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureCoordinateElement[] = {  {&_swigt__p_SoMultiTextureCoordinateElement, 0, 0, 0},  {&_swigt__p_SoGLMultiTextureCoordinateElement, _p_SoGLMultiTextureCoordinateElementTo_p_SoMultiTextureCoordinateElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureEnabledElement[] = {  {&_swigt__p_SoMultiTextureEnabledElement, 0, 0, 0},  {&_swigt__p_SoGLMultiTextureEnabledElement, _p_SoGLMultiTextureEnabledElementTo_p_SoMultiTextureEnabledElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureEnabledElement__Mode[] = {  {&_swigt__p_SoMultiTextureEnabledElement__Mode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureImageElement[] = {  {&_swigt__p_SoMultiTextureImageElement, 0, 0, 0},  {&_swigt__p_SoGLMultiTextureImageElement, _p_SoGLMultiTextureImageElementTo_p_SoMultiTextureImageElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureImageElement__Model[] = {  {&_swigt__p_SoMultiTextureImageElement__Model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureImageElement__Wrap[] = {  {&_swigt__p_SoMultiTextureImageElement__Wrap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultiTextureMatrixElement[] = {  {&_swigt__p_SoMultiTextureMatrixElement, 0, 0, 0},  {&_swigt__p_SoGLMultiTextureMatrixElement, _p_SoGLMultiTextureMatrixElementTo_p_SoMultiTextureMatrixElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoMultipleCopy[] = {  {&_swigt__p_SoMultipleCopy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNode[] = {  {&_swigt__p_SoNode, 0, 0, 0},  {&_swigt__p_SoAlphaTest, _p_SoAlphaTestTo_p_SoNode, 0, 0},  {&_swigt__p_SoAnnotation, _p_SoAnnotationTo_p_SoNode, 0, 0},  {&_swigt__p_SoAntiSquish, _p_SoAntiSquishTo_p_SoNode, 0, 0},  {&_swigt__p_SoAppearanceKit, _p_SoAppearanceKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoArray, _p_SoArrayTo_p_SoNode, 0, 0},  {&_swigt__p_SoAsciiText, _p_SoAsciiTextTo_p_SoNode, 0, 0},  {&_swigt__p_SoBaseColor, _p_SoBaseColorTo_p_SoNode, 0, 0},  {&_swigt__p_SoBaseKit, _p_SoBaseKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoBlinker, _p_SoBlinkerTo_p_SoNode, 0, 0},  {&_swigt__p_SoBumpMap, _p_SoBumpMapTo_p_SoNode, 0, 0},  {&_swigt__p_SoBumpMapCoordinate, _p_SoBumpMapCoordinateTo_p_SoNode, 0, 0},  {&_swigt__p_SoBumpMapTransform, _p_SoBumpMapTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoCacheHint, _p_SoCacheHintTo_p_SoNode, 0, 0},  {&_swigt__p_SoCallback, _p_SoCallbackTo_p_SoNode, 0, 0},  {&_swigt__p_SoCamera, _p_SoCameraTo_p_SoNode, 0, 0},  {&_swigt__p_SoCameraKit, _p_SoCameraKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoCenterballDragger, _p_SoCenterballDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoClipPlane, _p_SoClipPlaneTo_p_SoNode, 0, 0},  {&_swigt__p_SoClipPlaneManip, _p_SoClipPlaneManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoColorIndex, _p_SoColorIndexTo_p_SoNode, 0, 0},  {&_swigt__p_SoComplexity, _p_SoComplexityTo_p_SoNode, 0, 0},  {&_swigt__p_SoCone, _p_SoConeTo_p_SoNode, 0, 0},  {&_swigt__p_SoCoordinate3, _p_SoCoordinate3To_p_SoNode, 0, 0},  {&_swigt__p_SoCoordinate4, _p_SoCoordinate4To_p_SoNode, 0, 0},  {&_swigt__p_SoCube, _p_SoCubeTo_p_SoNode, 0, 0},  {&_swigt__p_SoCylinder, _p_SoCylinderTo_p_SoNode, 0, 0},  {&_swigt__p_SoDepthBuffer, _p_SoDepthBufferTo_p_SoNode, 0, 0},  {&_swigt__p_SoDirectionalLight, _p_SoDirectionalLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoDirectionalLightDragger, _p_SoDirectionalLightDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoDirectionalLightManip, _p_SoDirectionalLightManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoDragPointDragger, _p_SoDragPointDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoDragger, _p_SoDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoDrawStyle, _p_SoDrawStyleTo_p_SoNode, 0, 0},  {&_swigt__p_SoEnvironment, _p_SoEnvironmentTo_p_SoNode, 0, 0},  {&_swigt__p_SoEventCallback, _p_SoEventCallbackTo_p_SoNode, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoNode, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoFile, _p_SoFileTo_p_SoNode, 0, 0},  {&_swigt__p_SoFont, _p_SoFontTo_p_SoNode, 0, 0},  {&_swigt__p_SoFontStyle, _p_SoFontStyleTo_p_SoNode, 0, 0},  {&_swigt__p_SoFragmentShader, _p_SoFragmentShaderTo_p_SoNode, 0, 0},  {&_swigt__p_SoFrustumCamera, _p_SoFrustumCameraTo_p_SoNode, 0, 0},  {&_swigt__p_SoGeoCoordinate, _p_SoGeoCoordinateTo_p_SoNode, 0, 0},  {&_swigt__p_SoGeoLocation, _p_SoGeoLocationTo_p_SoNode, 0, 0},  {&_swigt__p_SoGeoOrigin, _p_SoGeoOriginTo_p_SoNode, 0, 0},  {&_swigt__p_SoGeoSeparator, _p_SoGeoSeparatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoGroup, _p_SoGroupTo_p_SoNode, 0, 0},  {&_swigt__p_SoHandleBoxDragger, _p_SoHandleBoxDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoImage, _p_SoImageTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedNurbsCurve, _p_SoIndexedNurbsCurveTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedNurbsSurface, _p_SoIndexedNurbsSurfaceTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedShape, _p_SoIndexedShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoInfo, _p_SoInfoTo_p_SoNode, 0, 0},  {&_swigt__p_SoInteractionKit, _p_SoInteractionKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoJackDragger, _p_SoJackDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoLOD, _p_SoLODTo_p_SoNode, 0, 0},  {&_swigt__p_SoLabel, _p_SoLabelTo_p_SoNode, 0, 0},  {&_swigt__p_SoLevelOfDetail, _p_SoLevelOfDetailTo_p_SoNode, 0, 0},  {&_swigt__p_SoLight, _p_SoLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoLightKit, _p_SoLightKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoLightModel, _p_SoLightModelTo_p_SoNode, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoLinearProfile, _p_SoLinearProfileTo_p_SoNode, 0, 0},  {&_swigt__p_SoListener, _p_SoListenerTo_p_SoNode, 0, 0},  {&_swigt__p_SoLocateHighlight, _p_SoLocateHighlightTo_p_SoNode, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoMaterial, _p_SoMaterialTo_p_SoNode, 0, 0},  {&_swigt__p_SoMaterialBinding, _p_SoMaterialBindingTo_p_SoNode, 0, 0},  {&_swigt__p_SoMatrixTransform, _p_SoMatrixTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoMultipleCopy, _p_SoMultipleCopyTo_p_SoNode, 0, 0},  {&_swigt__p_SoNodeEngine, _p_SoNodeEngineTo_p_SoNode, 0, 0},  {&_swigt__p_SoNodeKitListPart, _p_SoNodeKitListPartTo_p_SoNode, 0, 0},  {&_swigt__p_SoNonIndexedShape, _p_SoNonIndexedShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoNormal, _p_SoNormalTo_p_SoNode, 0, 0},  {&_swigt__p_SoNormalBinding, _p_SoNormalBindingTo_p_SoNode, 0, 0},  {&_swigt__p_SoNurbsCurve, _p_SoNurbsCurveTo_p_SoNode, 0, 0},  {&_swigt__p_SoNurbsProfile, _p_SoNurbsProfileTo_p_SoNode, 0, 0},  {&_swigt__p_SoNurbsSurface, _p_SoNurbsSurfaceTo_p_SoNode, 0, 0},  {&_swigt__p_SoOrthographicCamera, _p_SoOrthographicCameraTo_p_SoNode, 0, 0},  {&_swigt__p_SoPackedColor, _p_SoPackedColorTo_p_SoNode, 0, 0},  {&_swigt__p_SoPathSwitch, _p_SoPathSwitchTo_p_SoNode, 0, 0},  {&_swigt__p_SoPendulum, _p_SoPendulumTo_p_SoNode, 0, 0},  {&_swigt__p_SoPerspectiveCamera, _p_SoPerspectiveCameraTo_p_SoNode, 0, 0},  {&_swigt__p_SoPickStyle, _p_SoPickStyleTo_p_SoNode, 0, 0},  {&_swigt__p_SoPointLight, _p_SoPointLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoPointLightDragger, _p_SoPointLightDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoPointLightManip, _p_SoPointLightManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoPolygonOffset, _p_SoPolygonOffsetTo_p_SoNode, 0, 0},  {&_swigt__p_SoProfile, _p_SoProfileTo_p_SoNode, 0, 0},  {&_swigt__p_SoProfileCoordinate2, _p_SoProfileCoordinate2To_p_SoNode, 0, 0},  {&_swigt__p_SoProfileCoordinate3, _p_SoProfileCoordinate3To_p_SoNode, 0, 0},  {&_swigt__p_SoProto, _p_SoProtoTo_p_SoNode, 0, 0},  {&_swigt__p_SoProtoInstance, _p_SoProtoInstanceTo_p_SoNode, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoNode, 0, 0},  {&_swigt__p_SoResetTransform, _p_SoResetTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoReversePerspectiveCamera, _p_SoReversePerspectiveCameraTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotateCylindricalDragger, _p_SoRotateCylindricalDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotateDiscDragger, _p_SoRotateDiscDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotateSphericalDragger, _p_SoRotateSphericalDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotation, _p_SoRotationTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotationXYZ, _p_SoRotationXYZTo_p_SoNode, 0, 0},  {&_swigt__p_SoRotor, _p_SoRotorTo_p_SoNode, 0, 0},  {&_swigt__p_SoScale, _p_SoScaleTo_p_SoNode, 0, 0},  {&_swigt__p_SoScale1Dragger, _p_SoScale1DraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoScale2Dragger, _p_SoScale2DraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoScale2UniformDragger, _p_SoScale2UniformDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoScaleUniformDragger, _p_SoScaleUniformDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoSceneKit, _p_SoSceneKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoSceneTexture2, _p_SoSceneTexture2To_p_SoNode, 0, 0},  {&_swigt__p_SoSceneTextureCubeMap, _p_SoSceneTextureCubeMapTo_p_SoNode, 0, 0},  {&_swigt__p_SoSelection, _p_SoSelectionTo_p_SoNode, 0, 0},  {&_swigt__p_SoSeparator, _p_SoSeparatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoSeparatorKit, _p_SoSeparatorKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderObject, _p_SoShaderObjectTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter, _p_SoShaderParameterTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter1f, _p_SoShaderParameter1fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter1i, _p_SoShaderParameter1iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter2f, _p_SoShaderParameter2fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter2i, _p_SoShaderParameter2iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter3f, _p_SoShaderParameter3fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter3i, _p_SoShaderParameter3iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter4f, _p_SoShaderParameter4fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameter4i, _p_SoShaderParameter4iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray1f, _p_SoShaderParameterArray1fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray1i, _p_SoShaderParameterArray1iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray2f, _p_SoShaderParameterArray2fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray2i, _p_SoShaderParameterArray2iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray3f, _p_SoShaderParameterArray3fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray3i, _p_SoShaderParameterArray3iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray4f, _p_SoShaderParameterArray4fTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterArray4i, _p_SoShaderParameterArray4iTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterMatrix, _p_SoShaderParameterMatrixTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderParameterMatrixArray, _p_SoShaderParameterMatrixArrayTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderProgram, _p_SoShaderProgramTo_p_SoNode, 0, 0},  {&_swigt__p_SoShaderStateMatrixParameter, _p_SoShaderStateMatrixParameterTo_p_SoNode, 0, 0},  {&_swigt__p_SoShape, _p_SoShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoShapeHints, _p_SoShapeHintsTo_p_SoNode, 0, 0},  {&_swigt__p_SoShapeKit, _p_SoShapeKitTo_p_SoNode, 0, 0},  {&_swigt__p_SoShuttle, _p_SoShuttleTo_p_SoNode, 0, 0},  {&_swigt__p_SoSphere, _p_SoSphereTo_p_SoNode, 0, 0},  {&_swigt__p_SoSpotLight, _p_SoSpotLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoSpotLightDragger, _p_SoSpotLightDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoSpotLightManip, _p_SoSpotLightManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoSurroundScale, _p_SoSurroundScaleTo_p_SoNode, 0, 0},  {&_swigt__p_SoSwitch, _p_SoSwitchTo_p_SoNode, 0, 0},  {&_swigt__p_SoTabBoxDragger, _p_SoTabBoxDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoTabPlaneDragger, _p_SoTabPlaneDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoText2, _p_SoText2To_p_SoNode, 0, 0},  {&_swigt__p_SoText3, _p_SoText3To_p_SoNode, 0, 0},  {&_swigt__p_SoTexture, _p_SoTextureTo_p_SoNode, 0, 0},  {&_swigt__p_SoTexture2, _p_SoTexture2To_p_SoNode, 0, 0},  {&_swigt__p_SoTexture2Transform, _p_SoTexture2TransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoTexture3, _p_SoTexture3To_p_SoNode, 0, 0},  {&_swigt__p_SoTexture3Transform, _p_SoTexture3TransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCombine, _p_SoTextureCombineTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinate2, _p_SoTextureCoordinate2To_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinate3, _p_SoTextureCoordinate3To_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateBinding, _p_SoTextureCoordinateBindingTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateCube, _p_SoTextureCoordinateCubeTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateCylinder, _p_SoTextureCoordinateCylinderTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateDefault, _p_SoTextureCoordinateDefaultTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateEnvironment, _p_SoTextureCoordinateEnvironmentTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateFunction, _p_SoTextureCoordinateFunctionTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateNormalMap, _p_SoTextureCoordinateNormalMapTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateObject, _p_SoTextureCoordinateObjectTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinatePlane, _p_SoTextureCoordinatePlaneTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateReflectionMap, _p_SoTextureCoordinateReflectionMapTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCoordinateSphere, _p_SoTextureCoordinateSphereTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureCubeMap, _p_SoTextureCubeMapTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureMatrixTransform, _p_SoTextureMatrixTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureScalePolicy, _p_SoTextureScalePolicyTo_p_SoNode, 0, 0},  {&_swigt__p_SoTextureUnit, _p_SoTextureUnitTo_p_SoNode, 0, 0},  {&_swigt__p_SoTrackballDragger, _p_SoTrackballDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransform, _p_SoTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformBoxDragger, _p_SoTransformBoxDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformManip, _p_SoTransformManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformSeparator, _p_SoTransformSeparatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformation, _p_SoTransformationTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformerDragger, _p_SoTransformerDraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoNode, 0, 0},  {&_swigt__p_SoTranslate1Dragger, _p_SoTranslate1DraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTranslate2Dragger, _p_SoTranslate2DraggerTo_p_SoNode, 0, 0},  {&_swigt__p_SoTranslation, _p_SoTranslationTo_p_SoNode, 0, 0},  {&_swigt__p_SoTransparencyType, _p_SoTransparencyTypeTo_p_SoNode, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoUniformShaderParameter, _p_SoUniformShaderParameterTo_p_SoNode, 0, 0},  {&_swigt__p_SoUnits, _p_SoUnitsTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLAnchor, _p_SoVRMLAnchorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLAppearance, _p_SoVRMLAppearanceTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLAudioClip, _p_SoVRMLAudioClipTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLBackground, _p_SoVRMLBackgroundTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLBillboard, _p_SoVRMLBillboardTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLBox, _p_SoVRMLBoxTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLColor, _p_SoVRMLColorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLColorInterpolator, _p_SoVRMLColorInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCone, _p_SoVRMLConeTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCoordinate, _p_SoVRMLCoordinateTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCoordinateInterpolator, _p_SoVRMLCoordinateInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCylinder, _p_SoVRMLCylinderTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLCylinderSensor, _p_SoVRMLCylinderSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLDirectionalLight, _p_SoVRMLDirectionalLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLDragSensor, _p_SoVRMLDragSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLElevationGrid, _p_SoVRMLElevationGridTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLExtrusion, _p_SoVRMLExtrusionTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLFog, _p_SoVRMLFogTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLFontStyle, _p_SoVRMLFontStyleTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLGeometry, _p_SoVRMLGeometryTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLGroup, _p_SoVRMLGroupTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLImageTexture, _p_SoVRMLImageTextureTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLInline, _p_SoVRMLInlineTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLInterpolator, _p_SoVRMLInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLLOD, _p_SoVRMLLODTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLLight, _p_SoVRMLLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLMaterial, _p_SoVRMLMaterialTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLMovieTexture, _p_SoVRMLMovieTextureTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLNavigationInfo, _p_SoVRMLNavigationInfoTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLNormal, _p_SoVRMLNormalTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLNormalInterpolator, _p_SoVRMLNormalInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLOrientationInterpolator, _p_SoVRMLOrientationInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLParent, _p_SoVRMLParentTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLPixelTexture, _p_SoVRMLPixelTextureTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLPlaneSensor, _p_SoVRMLPlaneSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLPointLight, _p_SoVRMLPointLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLPositionInterpolator, _p_SoVRMLPositionInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLProximitySensor, _p_SoVRMLProximitySensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLScalarInterpolator, _p_SoVRMLScalarInterpolatorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLScript, _p_SoVRMLScriptTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSensor, _p_SoVRMLSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLShape, _p_SoVRMLShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSound, _p_SoVRMLSoundTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSphere, _p_SoVRMLSphereTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSphereSensor, _p_SoVRMLSphereSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSpotLight, _p_SoVRMLSpotLightTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLSwitch, _p_SoVRMLSwitchTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLText, _p_SoVRMLTextTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTexture, _p_SoVRMLTextureTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTextureCoordinate, _p_SoVRMLTextureCoordinateTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTextureTransform, _p_SoVRMLTextureTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTimeSensor, _p_SoVRMLTimeSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTouchSensor, _p_SoVRMLTouchSensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLVertexLine, _p_SoVRMLVertexLineTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLVertexPoint, _p_SoVRMLVertexPointTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLVertexShape, _p_SoVRMLVertexShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLViewpoint, _p_SoVRMLViewpointTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLVisibilitySensor, _p_SoVRMLVisibilitySensorTo_p_SoNode, 0, 0},  {&_swigt__p_SoVRMLWorldInfo, _p_SoVRMLWorldInfoTo_p_SoNode, 0, 0},  {&_swigt__p_SoVertexAttribute, _p_SoVertexAttributeTo_p_SoNode, 0, 0},  {&_swigt__p_SoVertexAttributeBinding, _p_SoVertexAttributeBindingTo_p_SoNode, 0, 0},  {&_swigt__p_SoVertexProperty, _p_SoVertexPropertyTo_p_SoNode, 0, 0},  {&_swigt__p_SoVertexShader, _p_SoVertexShaderTo_p_SoNode, 0, 0},  {&_swigt__p_SoVertexShape, _p_SoVertexShapeTo_p_SoNode, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoNode, 0, 0},  {&_swigt__p_SoWWWInline, _p_SoWWWInlineTo_p_SoNode, 0, 0},  {&_swigt__p_SoWrapperKit, _p_SoWrapperKitTo_p_SoNode, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeEngine[] = {  {&_swigt__p_SoNodeEngine, 0, 0, 0},  {&_swigt__p_SoVRMLColorInterpolator, _p_SoVRMLColorInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLCoordinateInterpolator, _p_SoVRMLCoordinateInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLInterpolator, _p_SoVRMLInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLNormalInterpolator, _p_SoVRMLNormalInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLOrientationInterpolator, _p_SoVRMLOrientationInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLPositionInterpolator, _p_SoVRMLPositionInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLScalarInterpolator, _p_SoVRMLScalarInterpolatorTo_p_SoNodeEngine, 0, 0},  {&_swigt__p_SoVRMLTimeSensor, _p_SoVRMLTimeSensorTo_p_SoNodeEngine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeKit[] = {  {&_swigt__p_SoNodeKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeKitDetail[] = {  {&_swigt__p_SoNodeKitDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeKitListPart[] = {  {&_swigt__p_SoNodeKitListPart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeKitPath[] = {  {&_swigt__p_SoNodeKitPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeList[] = {  {&_swigt__p_SoNodeList, 0, 0, 0},  {&_swigt__p_SoChildList, _p_SoChildListTo_p_SoNodeList, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeSensor[] = {  {&_swigt__p_SoNodeSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodekitCatalog[] = {  {&_swigt__p_SoNodekitCatalog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNonIndexedShape[] = {  {&_swigt__p_SoNonIndexedShape, 0, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoNonIndexedShape, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoNonIndexedShape, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoNonIndexedShape, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoNonIndexedShape, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoNonIndexedShape, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoNonIndexedShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormal[] = {  {&_swigt__p_SoNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalBinding[] = {  {&_swigt__p_SoNormalBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalBindingElement[] = {  {&_swigt__p_SoNormalBindingElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalBundle[] = {  {&_swigt__p_SoNormalBundle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalCache[] = {  {&_swigt__p_SoNormalCache, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalElement[] = {  {&_swigt__p_SoNormalElement, 0, 0, 0},  {&_swigt__p_SoGLNormalElement, _p_SoGLNormalElementTo_p_SoNormalElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNormalGenerator[] = {  {&_swigt__p_SoNormalGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNotList[] = {  {&_swigt__p_SoNotList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNotRec[] = {  {&_swigt__p_SoNotRec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNurbsCurve[] = {  {&_swigt__p_SoNurbsCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNurbsProfile[] = {  {&_swigt__p_SoNurbsProfile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNurbsSurface[] = {  {&_swigt__p_SoNurbsSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOffscreenRenderer[] = {  {&_swigt__p_SoOffscreenRenderer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOnOff[] = {  {&_swigt__p_SoOnOff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOneShot[] = {  {&_swigt__p_SoOneShot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOneShotSensor[] = {  {&_swigt__p_SoOneShotSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOrthographicCamera[] = {  {&_swigt__p_SoOrthographicCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOutput[] = {  {&_swigt__p_SoOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoOverrideElement[] = {  {&_swigt__p_SoOverrideElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPSVectorOutput[] = {  {&_swigt__p_SoPSVectorOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPackedColor[] = {  {&_swigt__p_SoPackedColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPath[] = {  {&_swigt__p_SoPath, 0, 0, 0},  {&_swigt__p_SoFullPath, _p_SoFullPathTo_p_SoPath, 0, 0},  {&_swigt__p_SoNodeKitPath, _p_SoNodeKitPathTo_p_SoPath, 0, 0},  {&_swigt__p_SoTempPath, _p_SoTempPathTo_p_SoPath, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPathList[] = {  {&_swigt__p_SoPathList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPathSensor[] = {  {&_swigt__p_SoPathSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPathSwitch[] = {  {&_swigt__p_SoPathSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPendulum[] = {  {&_swigt__p_SoPendulum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPerspectiveCamera[] = {  {&_swigt__p_SoPerspectiveCamera, 0, 0, 0},  {&_swigt__p_SoReversePerspectiveCamera, _p_SoReversePerspectiveCameraTo_p_SoPerspectiveCamera, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickAction[] = {  {&_swigt__p_SoPickAction, 0, 0, 0},  {&_swigt__p_SoRayPickAction, _p_SoRayPickActionTo_p_SoPickAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickRayElement[] = {  {&_swigt__p_SoPickRayElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickStyle[] = {  {&_swigt__p_SoPickStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickStyleElement[] = {  {&_swigt__p_SoPickStyleElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickedPoint[] = {  {&_swigt__p_SoPickedPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPickedPointList[] = {  {&_swigt__p_SoPickedPointList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointDetail[] = {  {&_swigt__p_SoPointDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointLight[] = {  {&_swigt__p_SoPointLight, 0, 0, 0},  {&_swigt__p_SoPointLightManip, _p_SoPointLightManipTo_p_SoPointLight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointLightDragger[] = {  {&_swigt__p_SoPointLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointLightManip[] = {  {&_swigt__p_SoPointLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointSet[] = {  {&_swigt__p_SoPointSet, 0, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoPointSet, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPointSizeElement[] = {  {&_swigt__p_SoPointSizeElement, 0, 0, 0},  {&_swigt__p_SoGLPointSizeElement, _p_SoGLPointSizeElementTo_p_SoPointSizeElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPolygonOffset[] = {  {&_swigt__p_SoPolygonOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPolygonOffsetElement[] = {  {&_swigt__p_SoPolygonOffsetElement, 0, 0, 0},  {&_swigt__p_SoGLPolygonOffsetElement, _p_SoGLPolygonOffsetElementTo_p_SoPolygonOffsetElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPolygonOffsetElement__Style[] = {  {&_swigt__p_SoPolygonOffsetElement__Style, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoPrimitiveVertex[] = {  {&_swigt__p_SoPrimitiveVertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProfile[] = {  {&_swigt__p_SoProfile, 0, 0, 0},  {&_swigt__p_SoLinearProfile, _p_SoLinearProfileTo_p_SoProfile, 0, 0},  {&_swigt__p_SoNurbsProfile, _p_SoNurbsProfileTo_p_SoProfile, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProfileCoordinate2[] = {  {&_swigt__p_SoProfileCoordinate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProfileCoordinate3[] = {  {&_swigt__p_SoProfileCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProfileCoordinateElement[] = {  {&_swigt__p_SoProfileCoordinateElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProfileElement[] = {  {&_swigt__p_SoProfileElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProjectionMatrixElement[] = {  {&_swigt__p_SoProjectionMatrixElement, 0, 0, 0},  {&_swigt__p_SoGLProjectionMatrixElement, _p_SoGLProjectionMatrixElementTo_p_SoProjectionMatrixElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProto[] = {  {&_swigt__p_SoProto, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoProtoInstance[] = {  {&_swigt__p_SoProtoInstance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQuadMesh[] = {  {&_swigt__p_SoQuadMesh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRayPickAction[] = {  {&_swigt__p_SoRayPickAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoReadError[] = {  {&_swigt__p_SoReadError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRenderManager[] = {  {&_swigt__p_SoRenderManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRenderManager__Superimposition[] = {  {&_swigt__p_SoRenderManager__Superimposition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoReorganizeAction[] = {  {&_swigt__p_SoReorganizeAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoReplacedElement[] = {  {&_swigt__p_SoReplacedElement, 0, 0, 0},  {&_swigt__p_SoAmbientColorElement, _p_SoAmbientColorElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoBumpMapCoordinateElement, _p_SoBumpMapCoordinateElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoBumpMapElement, _p_SoBumpMapElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoCoordinateElement, _p_SoCoordinateElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoDiffuseColorElement, _p_SoDiffuseColorElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoEmissiveColorElement, _p_SoEmissiveColorElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoEnvironmentElement, _p_SoEnvironmentElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoFontNameElement, _p_SoFontNameElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLColorIndexElement, _p_SoGLColorIndexElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLCoordinateElement, _p_SoGLCoordinateElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLEnvironmentElement, _p_SoGLEnvironmentElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLNormalElement, _p_SoGLNormalElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLPolygonOffsetElement, _p_SoGLPolygonOffsetElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLProjectionMatrixElement, _p_SoGLProjectionMatrixElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoGLViewingMatrixElement, _p_SoGLViewingMatrixElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoLightAttenuationElement, _p_SoLightAttenuationElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoListenerDopplerElement, _p_SoListenerDopplerElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoListenerOrientationElement, _p_SoListenerOrientationElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoListenerPositionElement, _p_SoListenerPositionElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoNormalElement, _p_SoNormalElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoPolygonOffsetElement, _p_SoPolygonOffsetElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoProfileCoordinateElement, _p_SoProfileCoordinateElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoProjectionMatrixElement, _p_SoProjectionMatrixElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoShininessElement, _p_SoShininessElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoSoundElement, _p_SoSoundElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoSpecularColorElement, _p_SoSpecularColorElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoTransparencyElement, _p_SoTransparencyElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoViewVolumeElement, _p_SoViewVolumeElementTo_p_SoReplacedElement, 0, 0},  {&_swigt__p_SoViewingMatrixElement, _p_SoViewingMatrixElementTo_p_SoReplacedElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoResetTransform[] = {  {&_swigt__p_SoResetTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoReversePerspectiveCamera[] = {  {&_swigt__p_SoReversePerspectiveCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotateCylindricalDragger[] = {  {&_swigt__p_SoRotateCylindricalDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotateDiscDragger[] = {  {&_swigt__p_SoRotateDiscDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotateSphericalDragger[] = {  {&_swigt__p_SoRotateSphericalDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotation[] = {  {&_swigt__p_SoRotation, 0, 0, 0},  {&_swigt__p_SoPendulum, _p_SoPendulumTo_p_SoRotation, 0, 0},  {&_swigt__p_SoRotor, _p_SoRotorTo_p_SoRotation, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotationXYZ[] = {  {&_swigt__p_SoRotationXYZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoRotor[] = {  {&_swigt__p_SoRotor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBitMask[] = {  {&_swigt__p_SoSFBitMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBool[] = {  {&_swigt__p_SoSFBool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox2d[] = {  {&_swigt__p_SoSFBox2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox2f[] = {  {&_swigt__p_SoSFBox2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox2i32[] = {  {&_swigt__p_SoSFBox2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox2s[] = {  {&_swigt__p_SoSFBox2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox3d[] = {  {&_swigt__p_SoSFBox3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox3f[] = {  {&_swigt__p_SoSFBox3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox3i32[] = {  {&_swigt__p_SoSFBox3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFBox3s[] = {  {&_swigt__p_SoSFBox3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFColor[] = {  {&_swigt__p_SoSFColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFColorRGBA[] = {  {&_swigt__p_SoSFColorRGBA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFDouble[] = {  {&_swigt__p_SoSFDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFEngine[] = {  {&_swigt__p_SoSFEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFEnum[] = {  {&_swigt__p_SoSFEnum, 0, 0, 0},  {&_swigt__p_SoSFBitMask, _p_SoSFBitMaskTo_p_SoSFEnum, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFFloat[] = {  {&_swigt__p_SoSFFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFImage[] = {  {&_swigt__p_SoSFImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFImage3[] = {  {&_swigt__p_SoSFImage3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFInt32[] = {  {&_swigt__p_SoSFInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFMatrix[] = {  {&_swigt__p_SoSFMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFName[] = {  {&_swigt__p_SoSFName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFNode[] = {  {&_swigt__p_SoSFNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFPath[] = {  {&_swigt__p_SoSFPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFPlane[] = {  {&_swigt__p_SoSFPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFRotation[] = {  {&_swigt__p_SoSFRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFShort[] = {  {&_swigt__p_SoSFShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFString[] = {  {&_swigt__p_SoSFString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFTime[] = {  {&_swigt__p_SoSFTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFTrigger[] = {  {&_swigt__p_SoSFTrigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFUInt32[] = {  {&_swigt__p_SoSFUInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFUShort[] = {  {&_swigt__p_SoSFUShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec2b[] = {  {&_swigt__p_SoSFVec2b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec2d[] = {  {&_swigt__p_SoSFVec2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec2f[] = {  {&_swigt__p_SoSFVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec2i32[] = {  {&_swigt__p_SoSFVec2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec2s[] = {  {&_swigt__p_SoSFVec2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec3b[] = {  {&_swigt__p_SoSFVec3b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec3d[] = {  {&_swigt__p_SoSFVec3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec3f[] = {  {&_swigt__p_SoSFVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec3i32[] = {  {&_swigt__p_SoSFVec3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec3s[] = {  {&_swigt__p_SoSFVec3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4b[] = {  {&_swigt__p_SoSFVec4b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4d[] = {  {&_swigt__p_SoSFVec4d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4f[] = {  {&_swigt__p_SoSFVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4i32[] = {  {&_swigt__p_SoSFVec4i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4s[] = {  {&_swigt__p_SoSFVec4s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4ub[] = {  {&_swigt__p_SoSFVec4ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4ui32[] = {  {&_swigt__p_SoSFVec4ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSFVec4us[] = {  {&_swigt__p_SoSFVec4us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSField[] = {  {&_swigt__p_SoSField, 0, 0, 0},  {&_swigt__p_SoSFBitMask, _p_SoSFBitMaskTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBool, _p_SoSFBoolTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox2d, _p_SoSFBox2dTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox2f, _p_SoSFBox2fTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox2i32, _p_SoSFBox2i32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox2s, _p_SoSFBox2sTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox3d, _p_SoSFBox3dTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox3f, _p_SoSFBox3fTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox3i32, _p_SoSFBox3i32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFBox3s, _p_SoSFBox3sTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFColor, _p_SoSFColorTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFColorRGBA, _p_SoSFColorRGBATo_p_SoSField, 0, 0},  {&_swigt__p_SoSFDouble, _p_SoSFDoubleTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFEngine, _p_SoSFEngineTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFEnum, _p_SoSFEnumTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFFloat, _p_SoSFFloatTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFImage, _p_SoSFImageTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFImage3, _p_SoSFImage3To_p_SoSField, 0, 0},  {&_swigt__p_SoSFInt32, _p_SoSFInt32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFMatrix, _p_SoSFMatrixTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFName, _p_SoSFNameTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFNode, _p_SoSFNodeTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFPath, _p_SoSFPathTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFPlane, _p_SoSFPlaneTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFRotation, _p_SoSFRotationTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFShort, _p_SoSFShortTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFString, _p_SoSFStringTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFTime, _p_SoSFTimeTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFTrigger, _p_SoSFTriggerTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFUInt32, _p_SoSFUInt32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFUShort, _p_SoSFUShortTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec2b, _p_SoSFVec2bTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec2d, _p_SoSFVec2dTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec2f, _p_SoSFVec2fTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec2i32, _p_SoSFVec2i32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec2s, _p_SoSFVec2sTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec3b, _p_SoSFVec3bTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec3d, _p_SoSFVec3dTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec3f, _p_SoSFVec3fTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec3i32, _p_SoSFVec3i32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec3s, _p_SoSFVec3sTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4b, _p_SoSFVec4bTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4d, _p_SoSFVec4dTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4f, _p_SoSFVec4fTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4i32, _p_SoSFVec4i32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4s, _p_SoSFVec4sTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4ub, _p_SoSFVec4ubTo_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4ui32, _p_SoSFVec4ui32To_p_SoSField, 0, 0},  {&_swigt__p_SoSFVec4us, _p_SoSFVec4usTo_p_SoSField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLDollyTarget[] = {  {&_swigt__p_SoScXMLDollyTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLEvent[] = {  {&_swigt__p_SoScXMLEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLFlightControlTarget[] = {  {&_swigt__p_SoScXMLFlightControlTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLMiscTarget[] = {  {&_swigt__p_SoScXMLMiscTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLMotionTarget[] = {  {&_swigt__p_SoScXMLMotionTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLNavigation[] = {  {&_swigt__p_SoScXMLNavigation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLNavigationTarget[] = {  {&_swigt__p_SoScXMLNavigationTarget, 0, 0, 0},  {&_swigt__p_SoScXMLDollyTarget, _p_SoScXMLDollyTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLFlightControlTarget, _p_SoScXMLFlightControlTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLMiscTarget, _p_SoScXMLMiscTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLMotionTarget, _p_SoScXMLMotionTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLPanTarget, _p_SoScXMLPanTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLRotateTarget, _p_SoScXMLRotateTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLSeekTarget, _p_SoScXMLSeekTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLSpinTarget, _p_SoScXMLSpinTargetTo_p_SoScXMLNavigationTarget, 0, 0},  {&_swigt__p_SoScXMLZoomTarget, _p_SoScXMLZoomTargetTo_p_SoScXMLNavigationTarget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLPanTarget[] = {  {&_swigt__p_SoScXMLPanTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLRotateTarget[] = {  {&_swigt__p_SoScXMLRotateTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLSeekTarget[] = {  {&_swigt__p_SoScXMLSeekTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLSpinTarget[] = {  {&_swigt__p_SoScXMLSpinTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLStateMachine[] = {  {&_swigt__p_SoScXMLStateMachine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScXMLZoomTarget[] = {  {&_swigt__p_SoScXMLZoomTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScale[] = {  {&_swigt__p_SoScale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScale1Dragger[] = {  {&_swigt__p_SoScale1Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScale2Dragger[] = {  {&_swigt__p_SoScale2Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScale2UniformDragger[] = {  {&_swigt__p_SoScale2UniformDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoScaleUniformDragger[] = {  {&_swigt__p_SoScaleUniformDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSceneKit[] = {  {&_swigt__p_SoSceneKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSceneManager[] = {  {&_swigt__p_SoSceneManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSceneTexture2[] = {  {&_swigt__p_SoSceneTexture2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSceneTextureCubeMap[] = {  {&_swigt__p_SoSceneTextureCubeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSearchAction[] = {  {&_swigt__p_SoSearchAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSelectOne[] = {  {&_swigt__p_SoSelectOne, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSelection[] = {  {&_swigt__p_SoSelection, 0, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoSelection, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSensor[] = {  {&_swigt__p_SoSensor, 0, 0, 0},  {&_swigt__p_SoAlarmSensor, _p_SoAlarmSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoDataSensor, _p_SoDataSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoDelayQueueSensor, _p_SoDelayQueueSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoFieldSensor, _p_SoFieldSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoIdleSensor, _p_SoIdleSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoNodeSensor, _p_SoNodeSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoOneShotSensor, _p_SoOneShotSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoPathSensor, _p_SoPathSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoTimerQueueSensor, _p_SoTimerQueueSensorTo_p_SoSensor, 0, 0},  {&_swigt__p_SoTimerSensor, _p_SoTimerSensorTo_p_SoSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSensorManager[] = {  {&_swigt__p_SoSensorManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSeparator[] = {  {&_swigt__p_SoSeparator, 0, 0, 0},  {&_swigt__p_SoAnnotation, _p_SoAnnotationTo_p_SoSeparator, 0, 0},  {&_swigt__p_SoExtSelection, _p_SoExtSelectionTo_p_SoSeparator, 0, 0},  {&_swigt__p_SoGeoSeparator, _p_SoGeoSeparatorTo_p_SoSeparator, 0, 0},  {&_swigt__p_SoLocateHighlight, _p_SoLocateHighlightTo_p_SoSeparator, 0, 0},  {&_swigt__p_SoSelection, _p_SoSelectionTo_p_SoSeparator, 0, 0},  {&_swigt__p_SoWWWAnchor, _p_SoWWWAnchorTo_p_SoSeparator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSeparatorKit[] = {  {&_swigt__p_SoSeparatorKit, 0, 0, 0},  {&_swigt__p_SoShapeKit, _p_SoShapeKitTo_p_SoSeparatorKit, 0, 0},  {&_swigt__p_SoWrapperKit, _p_SoWrapperKitTo_p_SoSeparatorKit, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderObject[] = {  {&_swigt__p_SoShaderObject, 0, 0, 0},  {&_swigt__p_SoFragmentShader, _p_SoFragmentShaderTo_p_SoShaderObject, 0, 0},  {&_swigt__p_SoVertexShader, _p_SoVertexShaderTo_p_SoShaderObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter[] = {  {&_swigt__p_SoShaderParameter, 0, 0, 0},  {&_swigt__p_SoShaderParameter1f, _p_SoShaderParameter1fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter1i, _p_SoShaderParameter1iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter2f, _p_SoShaderParameter2fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter2i, _p_SoShaderParameter2iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter3f, _p_SoShaderParameter3fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter3i, _p_SoShaderParameter3iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter4f, _p_SoShaderParameter4fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter4i, _p_SoShaderParameter4iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray1f, _p_SoShaderParameterArray1fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray1i, _p_SoShaderParameterArray1iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray2f, _p_SoShaderParameterArray2fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray2i, _p_SoShaderParameterArray2iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray3f, _p_SoShaderParameterArray3fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray3i, _p_SoShaderParameterArray3iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray4f, _p_SoShaderParameterArray4fTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray4i, _p_SoShaderParameterArray4iTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterMatrix, _p_SoShaderParameterMatrixTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterMatrixArray, _p_SoShaderParameterMatrixArrayTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoShaderStateMatrixParameter, _p_SoShaderStateMatrixParameterTo_p_SoShaderParameter, 0, 0},  {&_swigt__p_SoUniformShaderParameter, _p_SoUniformShaderParameterTo_p_SoShaderParameter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter1f[] = {  {&_swigt__p_SoShaderParameter1f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter1i[] = {  {&_swigt__p_SoShaderParameter1i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter2f[] = {  {&_swigt__p_SoShaderParameter2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter2i[] = {  {&_swigt__p_SoShaderParameter2i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter3f[] = {  {&_swigt__p_SoShaderParameter3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter3i[] = {  {&_swigt__p_SoShaderParameter3i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter4f[] = {  {&_swigt__p_SoShaderParameter4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter4i[] = {  {&_swigt__p_SoShaderParameter4i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray1f[] = {  {&_swigt__p_SoShaderParameterArray1f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray1i[] = {  {&_swigt__p_SoShaderParameterArray1i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray2f[] = {  {&_swigt__p_SoShaderParameterArray2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray2i[] = {  {&_swigt__p_SoShaderParameterArray2i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray3f[] = {  {&_swigt__p_SoShaderParameterArray3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray3i[] = {  {&_swigt__p_SoShaderParameterArray3i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray4f[] = {  {&_swigt__p_SoShaderParameterArray4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterArray4i[] = {  {&_swigt__p_SoShaderParameterArray4i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterMatrix[] = {  {&_swigt__p_SoShaderParameterMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameterMatrixArray[] = {  {&_swigt__p_SoShaderParameterMatrixArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderProgram[] = {  {&_swigt__p_SoShaderProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderStateMatrixParameter[] = {  {&_swigt__p_SoShaderStateMatrixParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShape[] = {  {&_swigt__p_SoShape, 0, 0, 0},  {&_swigt__p_SoAsciiText, _p_SoAsciiTextTo_p_SoShape, 0, 0},  {&_swigt__p_SoCone, _p_SoConeTo_p_SoShape, 0, 0},  {&_swigt__p_SoCube, _p_SoCubeTo_p_SoShape, 0, 0},  {&_swigt__p_SoCylinder, _p_SoCylinderTo_p_SoShape, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoImage, _p_SoImageTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedNurbsCurve, _p_SoIndexedNurbsCurveTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedNurbsSurface, _p_SoIndexedNurbsSurfaceTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedShape, _p_SoIndexedShapeTo_p_SoShape, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoNonIndexedShape, _p_SoNonIndexedShapeTo_p_SoShape, 0, 0},  {&_swigt__p_SoNurbsCurve, _p_SoNurbsCurveTo_p_SoShape, 0, 0},  {&_swigt__p_SoNurbsSurface, _p_SoNurbsSurfaceTo_p_SoShape, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoShape, 0, 0},  {&_swigt__p_SoSphere, _p_SoSphereTo_p_SoShape, 0, 0},  {&_swigt__p_SoText2, _p_SoText2To_p_SoShape, 0, 0},  {&_swigt__p_SoText3, _p_SoText3To_p_SoShape, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLBox, _p_SoVRMLBoxTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLCone, _p_SoVRMLConeTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLCylinder, _p_SoVRMLCylinderTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLElevationGrid, _p_SoVRMLElevationGridTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLExtrusion, _p_SoVRMLExtrusionTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLGeometry, _p_SoVRMLGeometryTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLSphere, _p_SoVRMLSphereTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLText, _p_SoVRMLTextTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLVertexLine, _p_SoVRMLVertexLineTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLVertexPoint, _p_SoVRMLVertexPointTo_p_SoShape, 0, 0},  {&_swigt__p_SoVRMLVertexShape, _p_SoVRMLVertexShapeTo_p_SoShape, 0, 0},  {&_swigt__p_SoVertexShape, _p_SoVertexShapeTo_p_SoShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeHints[] = {  {&_swigt__p_SoShapeHints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeHintsElement[] = {  {&_swigt__p_SoShapeHintsElement, 0, 0, 0},  {&_swigt__p_SoGLShapeHintsElement, _p_SoGLShapeHintsElementTo_p_SoShapeHintsElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeHintsElement__FaceType[] = {  {&_swigt__p_SoShapeHintsElement__FaceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeHintsElement__ShapeType[] = {  {&_swigt__p_SoShapeHintsElement__ShapeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeHintsElement__VertexOrdering[] = {  {&_swigt__p_SoShapeHintsElement__VertexOrdering, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeKit[] = {  {&_swigt__p_SoShapeKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShapeStyleElement[] = {  {&_swigt__p_SoShapeStyleElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShininessElement[] = {  {&_swigt__p_SoShininessElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShuttle[] = {  {&_swigt__p_SoShuttle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSimplifier[] = {  {&_swigt__p_SoSimplifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSimplifyAction[] = {  {&_swigt__p_SoSimplifyAction, 0, 0, 0},  {&_swigt__p_SoReorganizeAction, _p_SoReorganizeActionTo_p_SoSimplifyAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSoundElement[] = {  {&_swigt__p_SoSoundElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpaceballButtonEvent[] = {  {&_swigt__p_SoSpaceballButtonEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpecularColorElement[] = {  {&_swigt__p_SoSpecularColorElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSphere[] = {  {&_swigt__p_SoSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpotLight[] = {  {&_swigt__p_SoSpotLight, 0, 0, 0},  {&_swigt__p_SoSpotLightManip, _p_SoSpotLightManipTo_p_SoSpotLight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpotLightDragger[] = {  {&_swigt__p_SoSpotLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpotLightManip[] = {  {&_swigt__p_SoSpotLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoState[] = {  {&_swigt__p_SoState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSurroundScale[] = {  {&_swigt__p_SoSurroundScale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSwitch[] = {  {&_swigt__p_SoSwitch, 0, 0, 0},  {&_swigt__p_SoBlinker, _p_SoBlinkerTo_p_SoSwitch, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSwitchElement[] = {  {&_swigt__p_SoSwitchElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTabBoxDragger[] = {  {&_swigt__p_SoTabBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTabBoxManip[] = {  {&_swigt__p_SoTabBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTabPlaneDragger[] = {  {&_swigt__p_SoTabPlaneDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTempPath[] = {  {&_swigt__p_SoTempPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoText2[] = {  {&_swigt__p_SoText2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoText3[] = {  {&_swigt__p_SoText3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextDetail[] = {  {&_swigt__p_SoTextDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextOutlineEnabledElement[] = {  {&_swigt__p_SoTextOutlineEnabledElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture[] = {  {&_swigt__p_SoTexture, 0, 0, 0},  {&_swigt__p_SoTexture2, _p_SoTexture2To_p_SoTexture, 0, 0},  {&_swigt__p_SoTexture3, _p_SoTexture3To_p_SoTexture, 0, 0},  {&_swigt__p_SoTextureCubeMap, _p_SoTextureCubeMapTo_p_SoTexture, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture2[] = {  {&_swigt__p_SoTexture2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture2Convert[] = {  {&_swigt__p_SoTexture2Convert, 0, 0, 0},  {&_swigt__p_SoHeightMapToNormalMap, _p_SoHeightMapToNormalMapTo_p_SoTexture2Convert, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture2Transform[] = {  {&_swigt__p_SoTexture2Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture3[] = {  {&_swigt__p_SoTexture3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTexture3Transform[] = {  {&_swigt__p_SoTexture3Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCombine[] = {  {&_swigt__p_SoTextureCombine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCombineElement[] = {  {&_swigt__p_SoTextureCombineElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCombineElement__Operand[] = {  {&_swigt__p_SoTextureCombineElement__Operand, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCombineElement__Operation[] = {  {&_swigt__p_SoTextureCombineElement__Operation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCombineElement__Source[] = {  {&_swigt__p_SoTextureCombineElement__Source, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinate2[] = {  {&_swigt__p_SoTextureCoordinate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinate3[] = {  {&_swigt__p_SoTextureCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateBinding[] = {  {&_swigt__p_SoTextureCoordinateBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateBindingElement[] = {  {&_swigt__p_SoTextureCoordinateBindingElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateBundle[] = {  {&_swigt__p_SoTextureCoordinateBundle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateCache[] = {  {&_swigt__p_SoTextureCoordinateCache, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateCube[] = {  {&_swigt__p_SoTextureCoordinateCube, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateCylinder[] = {  {&_swigt__p_SoTextureCoordinateCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateDefault[] = {  {&_swigt__p_SoTextureCoordinateDefault, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateEnvironment[] = {  {&_swigt__p_SoTextureCoordinateEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateFunction[] = {  {&_swigt__p_SoTextureCoordinateFunction, 0, 0, 0},  {&_swigt__p_SoTextureCoordinateDefault, _p_SoTextureCoordinateDefaultTo_p_SoTextureCoordinateFunction, 0, 0},  {&_swigt__p_SoTextureCoordinateEnvironment, _p_SoTextureCoordinateEnvironmentTo_p_SoTextureCoordinateFunction, 0, 0},  {&_swigt__p_SoTextureCoordinateNormalMap, _p_SoTextureCoordinateNormalMapTo_p_SoTextureCoordinateFunction, 0, 0},  {&_swigt__p_SoTextureCoordinateObject, _p_SoTextureCoordinateObjectTo_p_SoTextureCoordinateFunction, 0, 0},  {&_swigt__p_SoTextureCoordinatePlane, _p_SoTextureCoordinatePlaneTo_p_SoTextureCoordinateFunction, 0, 0},  {&_swigt__p_SoTextureCoordinateReflectionMap, _p_SoTextureCoordinateReflectionMapTo_p_SoTextureCoordinateFunction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateNormalMap[] = {  {&_swigt__p_SoTextureCoordinateNormalMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateObject[] = {  {&_swigt__p_SoTextureCoordinateObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinatePlane[] = {  {&_swigt__p_SoTextureCoordinatePlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateReflectionMap[] = {  {&_swigt__p_SoTextureCoordinateReflectionMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCoordinateSphere[] = {  {&_swigt__p_SoTextureCoordinateSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureCubeMap[] = {  {&_swigt__p_SoTextureCubeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureMatrixTransform[] = {  {&_swigt__p_SoTextureMatrixTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureOverrideElement[] = {  {&_swigt__p_SoTextureOverrideElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureQualityElement[] = {  {&_swigt__p_SoTextureQualityElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureScalePolicy[] = {  {&_swigt__p_SoTextureScalePolicy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureUnit[] = {  {&_swigt__p_SoTextureUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTextureUnitElement[] = {  {&_swigt__p_SoTextureUnitElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTimeCounter[] = {  {&_swigt__p_SoTimeCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTimerQueueSensor[] = {  {&_swigt__p_SoTimerQueueSensor, 0, 0, 0},  {&_swigt__p_SoAlarmSensor, _p_SoAlarmSensorTo_p_SoTimerQueueSensor, 0, 0},  {&_swigt__p_SoTimerSensor, _p_SoTimerSensorTo_p_SoTimerQueueSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTimerSensor[] = {  {&_swigt__p_SoTimerSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoToVRML2Action[] = {  {&_swigt__p_SoToVRML2Action, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoToVRMLAction[] = {  {&_swigt__p_SoToVRMLAction, 0, 0, 0},  {&_swigt__p_SoToVRML2Action, _p_SoToVRML2ActionTo_p_SoToVRMLAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTrackballDragger[] = {  {&_swigt__p_SoTrackballDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTrackballManip[] = {  {&_swigt__p_SoTrackballManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTranReceiver[] = {  {&_swigt__p_SoTranReceiver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTranSender[] = {  {&_swigt__p_SoTranSender, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransform[] = {  {&_swigt__p_SoTransform, 0, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoTransformManip, _p_SoTransformManipTo_p_SoTransform, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoTransform, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformBoxDragger[] = {  {&_swigt__p_SoTransformBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformBoxManip[] = {  {&_swigt__p_SoTransformBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformManip[] = {  {&_swigt__p_SoTransformManip, 0, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoTransformManip, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoTransformManip, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformSeparator[] = {  {&_swigt__p_SoTransformSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformVec3f[] = {  {&_swigt__p_SoTransformVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformation[] = {  {&_swigt__p_SoTransformation, 0, 0, 0},  {&_swigt__p_SoAntiSquish, _p_SoAntiSquishTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoCenterballManip, _p_SoCenterballManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoGeoLocation, _p_SoGeoLocationTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoHandleBoxManip, _p_SoHandleBoxManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoJackManip, _p_SoJackManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoMatrixTransform, _p_SoMatrixTransformTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoPendulum, _p_SoPendulumTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoResetTransform, _p_SoResetTransformTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoRotation, _p_SoRotationTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoRotationXYZ, _p_SoRotationXYZTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoRotor, _p_SoRotorTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoScale, _p_SoScaleTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoShuttle, _p_SoShuttleTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoSurroundScale, _p_SoSurroundScaleTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTabBoxManip, _p_SoTabBoxManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTrackballManip, _p_SoTrackballManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTransform, _p_SoTransformTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTransformBoxManip, _p_SoTransformBoxManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTransformManip, _p_SoTransformManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTransformerManip, _p_SoTransformerManipTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoTranslation, _p_SoTranslationTo_p_SoTransformation, 0, 0},  {&_swigt__p_SoUnits, _p_SoUnitsTo_p_SoTransformation, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformerDragger[] = {  {&_swigt__p_SoTransformerDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransformerManip[] = {  {&_swigt__p_SoTransformerManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTranslate1Dragger[] = {  {&_swigt__p_SoTranslate1Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTranslate2Dragger[] = {  {&_swigt__p_SoTranslate2Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTranslation[] = {  {&_swigt__p_SoTranslation, 0, 0, 0},  {&_swigt__p_SoShuttle, _p_SoShuttleTo_p_SoTranslation, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransparencyElement[] = {  {&_swigt__p_SoTransparencyElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTransparencyType[] = {  {&_swigt__p_SoTransparencyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTriangleStripSet[] = {  {&_swigt__p_SoTriangleStripSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTriggerAny[] = {  {&_swigt__p_SoTriggerAny, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoType[] = {  {&_swigt__p_SoType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoTypeList[] = {  {&_swigt__p_SoTypeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoUniformShaderParameter[] = {  {&_swigt__p_SoUniformShaderParameter, 0, 0, 0},  {&_swigt__p_SoShaderParameter1f, _p_SoShaderParameter1fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter1i, _p_SoShaderParameter1iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter2f, _p_SoShaderParameter2fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter2i, _p_SoShaderParameter2iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter3f, _p_SoShaderParameter3fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter3i, _p_SoShaderParameter3iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter4f, _p_SoShaderParameter4fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameter4i, _p_SoShaderParameter4iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray1f, _p_SoShaderParameterArray1fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray1i, _p_SoShaderParameterArray1iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray2f, _p_SoShaderParameterArray2fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray2i, _p_SoShaderParameterArray2iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray3f, _p_SoShaderParameterArray3fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray3i, _p_SoShaderParameterArray3iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray4f, _p_SoShaderParameterArray4fTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterArray4i, _p_SoShaderParameterArray4iTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterMatrix, _p_SoShaderParameterMatrixTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderParameterMatrixArray, _p_SoShaderParameterMatrixArrayTo_p_SoUniformShaderParameter, 0, 0},  {&_swigt__p_SoShaderStateMatrixParameter, _p_SoShaderStateMatrixParameterTo_p_SoUniformShaderParameter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoUnits[] = {  {&_swigt__p_SoUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoUnitsElement[] = {  {&_swigt__p_SoUnitsElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVBO[] = {  {&_swigt__p_SoVBO, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLAnchor[] = {  {&_swigt__p_SoVRMLAnchor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLAppearance[] = {  {&_swigt__p_SoVRMLAppearance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLAudioClip[] = {  {&_swigt__p_SoVRMLAudioClip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLBackground[] = {  {&_swigt__p_SoVRMLBackground, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLBillboard[] = {  {&_swigt__p_SoVRMLBillboard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLBox[] = {  {&_swigt__p_SoVRMLBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCollision[] = {  {&_swigt__p_SoVRMLCollision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLColor[] = {  {&_swigt__p_SoVRMLColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLColorInterpolator[] = {  {&_swigt__p_SoVRMLColorInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCone[] = {  {&_swigt__p_SoVRMLCone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCoordinate[] = {  {&_swigt__p_SoVRMLCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCoordinateInterpolator[] = {  {&_swigt__p_SoVRMLCoordinateInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCylinder[] = {  {&_swigt__p_SoVRMLCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLCylinderSensor[] = {  {&_swigt__p_SoVRMLCylinderSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLDirectionalLight[] = {  {&_swigt__p_SoVRMLDirectionalLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLDragSensor[] = {  {&_swigt__p_SoVRMLDragSensor, 0, 0, 0},  {&_swigt__p_SoVRMLCylinderSensor, _p_SoVRMLCylinderSensorTo_p_SoVRMLDragSensor, 0, 0},  {&_swigt__p_SoVRMLPlaneSensor, _p_SoVRMLPlaneSensorTo_p_SoVRMLDragSensor, 0, 0},  {&_swigt__p_SoVRMLSphereSensor, _p_SoVRMLSphereSensorTo_p_SoVRMLDragSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLElevationGrid[] = {  {&_swigt__p_SoVRMLElevationGrid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLExtrusion[] = {  {&_swigt__p_SoVRMLExtrusion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLFog[] = {  {&_swigt__p_SoVRMLFog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLFontStyle[] = {  {&_swigt__p_SoVRMLFontStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLGeometry[] = {  {&_swigt__p_SoVRMLGeometry, 0, 0, 0},  {&_swigt__p_SoVRMLBox, _p_SoVRMLBoxTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLCone, _p_SoVRMLConeTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLCylinder, _p_SoVRMLCylinderTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLElevationGrid, _p_SoVRMLElevationGridTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLExtrusion, _p_SoVRMLExtrusionTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLSphere, _p_SoVRMLSphereTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLText, _p_SoVRMLTextTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLVertexLine, _p_SoVRMLVertexLineTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLVertexPoint, _p_SoVRMLVertexPointTo_p_SoVRMLGeometry, 0, 0},  {&_swigt__p_SoVRMLVertexShape, _p_SoVRMLVertexShapeTo_p_SoVRMLGeometry, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLGroup[] = {  {&_swigt__p_SoVRMLGroup, 0, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoVRMLGroup, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoVRMLGroup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLImageTexture[] = {  {&_swigt__p_SoVRMLImageTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLIndexedFaceSet[] = {  {&_swigt__p_SoVRMLIndexedFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLIndexedLine[] = {  {&_swigt__p_SoVRMLIndexedLine, 0, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoVRMLIndexedLine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLIndexedLineSet[] = {  {&_swigt__p_SoVRMLIndexedLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLIndexedShape[] = {  {&_swigt__p_SoVRMLIndexedShape, 0, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoVRMLIndexedShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLInline[] = {  {&_swigt__p_SoVRMLInline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLInterpolator[] = {  {&_swigt__p_SoVRMLInterpolator, 0, 0, 0},  {&_swigt__p_SoVRMLColorInterpolator, _p_SoVRMLColorInterpolatorTo_p_SoVRMLInterpolator, 0, 0},  {&_swigt__p_SoVRMLCoordinateInterpolator, _p_SoVRMLCoordinateInterpolatorTo_p_SoVRMLInterpolator, 0, 0},  {&_swigt__p_SoVRMLNormalInterpolator, _p_SoVRMLNormalInterpolatorTo_p_SoVRMLInterpolator, 0, 0},  {&_swigt__p_SoVRMLOrientationInterpolator, _p_SoVRMLOrientationInterpolatorTo_p_SoVRMLInterpolator, 0, 0},  {&_swigt__p_SoVRMLPositionInterpolator, _p_SoVRMLPositionInterpolatorTo_p_SoVRMLInterpolator, 0, 0},  {&_swigt__p_SoVRMLScalarInterpolator, _p_SoVRMLScalarInterpolatorTo_p_SoVRMLInterpolator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLLOD[] = {  {&_swigt__p_SoVRMLLOD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLLight[] = {  {&_swigt__p_SoVRMLLight, 0, 0, 0},  {&_swigt__p_SoVRMLDirectionalLight, _p_SoVRMLDirectionalLightTo_p_SoVRMLLight, 0, 0},  {&_swigt__p_SoVRMLPointLight, _p_SoVRMLPointLightTo_p_SoVRMLLight, 0, 0},  {&_swigt__p_SoVRMLSpotLight, _p_SoVRMLSpotLightTo_p_SoVRMLLight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLMaterial[] = {  {&_swigt__p_SoVRMLMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLMovieTexture[] = {  {&_swigt__p_SoVRMLMovieTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLNavigationInfo[] = {  {&_swigt__p_SoVRMLNavigationInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLNormal[] = {  {&_swigt__p_SoVRMLNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLNormalInterpolator[] = {  {&_swigt__p_SoVRMLNormalInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLOrientationInterpolator[] = {  {&_swigt__p_SoVRMLOrientationInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLParent[] = {  {&_swigt__p_SoVRMLParent, 0, 0, 0},  {&_swigt__p_SoVRMLAnchor, _p_SoVRMLAnchorTo_p_SoVRMLParent, 0, 0},  {&_swigt__p_SoVRMLBillboard, _p_SoVRMLBillboardTo_p_SoVRMLParent, 0, 0},  {&_swigt__p_SoVRMLCollision, _p_SoVRMLCollisionTo_p_SoVRMLParent, 0, 0},  {&_swigt__p_SoVRMLGroup, _p_SoVRMLGroupTo_p_SoVRMLParent, 0, 0},  {&_swigt__p_SoVRMLTransform, _p_SoVRMLTransformTo_p_SoVRMLParent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLPixelTexture[] = {  {&_swigt__p_SoVRMLPixelTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLPlaneSensor[] = {  {&_swigt__p_SoVRMLPlaneSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLPointLight[] = {  {&_swigt__p_SoVRMLPointLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLPointSet[] = {  {&_swigt__p_SoVRMLPointSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLPositionInterpolator[] = {  {&_swigt__p_SoVRMLPositionInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLProximitySensor[] = {  {&_swigt__p_SoVRMLProximitySensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLScalarInterpolator[] = {  {&_swigt__p_SoVRMLScalarInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLScript[] = {  {&_swigt__p_SoVRMLScript, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSensor[] = {  {&_swigt__p_SoVRMLSensor, 0, 0, 0},  {&_swigt__p_SoVRMLCylinderSensor, _p_SoVRMLCylinderSensorTo_p_SoVRMLSensor, 0, 0},  {&_swigt__p_SoVRMLDragSensor, _p_SoVRMLDragSensorTo_p_SoVRMLSensor, 0, 0},  {&_swigt__p_SoVRMLPlaneSensor, _p_SoVRMLPlaneSensorTo_p_SoVRMLSensor, 0, 0},  {&_swigt__p_SoVRMLSphereSensor, _p_SoVRMLSphereSensorTo_p_SoVRMLSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLShape[] = {  {&_swigt__p_SoVRMLShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSound[] = {  {&_swigt__p_SoVRMLSound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSphere[] = {  {&_swigt__p_SoVRMLSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSphereSensor[] = {  {&_swigt__p_SoVRMLSphereSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSpotLight[] = {  {&_swigt__p_SoVRMLSpotLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLSwitch[] = {  {&_swigt__p_SoVRMLSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLText[] = {  {&_swigt__p_SoVRMLText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTexture[] = {  {&_swigt__p_SoVRMLTexture, 0, 0, 0},  {&_swigt__p_SoVRMLImageTexture, _p_SoVRMLImageTextureTo_p_SoVRMLTexture, 0, 0},  {&_swigt__p_SoVRMLMovieTexture, _p_SoVRMLMovieTextureTo_p_SoVRMLTexture, 0, 0},  {&_swigt__p_SoVRMLPixelTexture, _p_SoVRMLPixelTextureTo_p_SoVRMLTexture, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTextureCoordinate[] = {  {&_swigt__p_SoVRMLTextureCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTextureTransform[] = {  {&_swigt__p_SoVRMLTextureTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTimeSensor[] = {  {&_swigt__p_SoVRMLTimeSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTouchSensor[] = {  {&_swigt__p_SoVRMLTouchSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLTransform[] = {  {&_swigt__p_SoVRMLTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVertexLine[] = {  {&_swigt__p_SoVRMLVertexLine, 0, 0, 0},  {&_swigt__p_SoVRMLIndexedLine, _p_SoVRMLIndexedLineTo_p_SoVRMLVertexLine, 0, 0},  {&_swigt__p_SoVRMLIndexedLineSet, _p_SoVRMLIndexedLineSetTo_p_SoVRMLVertexLine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVertexPoint[] = {  {&_swigt__p_SoVRMLVertexPoint, 0, 0, 0},  {&_swigt__p_SoVRMLPointSet, _p_SoVRMLPointSetTo_p_SoVRMLVertexPoint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVertexShape[] = {  {&_swigt__p_SoVRMLVertexShape, 0, 0, 0},  {&_swigt__p_SoVRMLIndexedFaceSet, _p_SoVRMLIndexedFaceSetTo_p_SoVRMLVertexShape, 0, 0},  {&_swigt__p_SoVRMLIndexedShape, _p_SoVRMLIndexedShapeTo_p_SoVRMLVertexShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLViewpoint[] = {  {&_swigt__p_SoVRMLViewpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVisibilitySensor[] = {  {&_swigt__p_SoVRMLVisibilitySensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLWorldInfo[] = {  {&_swigt__p_SoVRMLWorldInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVectorOutput[] = {  {&_swigt__p_SoVectorOutput, 0, 0, 0},  {&_swigt__p_SoPSVectorOutput, _p_SoPSVectorOutputTo_p_SoVectorOutput, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVectorizeAction[] = {  {&_swigt__p_SoVectorizeAction, 0, 0, 0},  {&_swigt__p_SoVectorizePSAction, _p_SoVectorizePSActionTo_p_SoVectorizeAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVectorizePSAction[] = {  {&_swigt__p_SoVectorizePSAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexAttribute[] = {  {&_swigt__p_SoVertexAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexAttributeBinding[] = {  {&_swigt__p_SoVertexAttributeBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexAttributeBindingElement[] = {  {&_swigt__p_SoVertexAttributeBindingElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexAttributeData[] = {  {&_swigt__p_SoVertexAttributeData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexAttributeElement[] = {  {&_swigt__p_SoVertexAttributeElement, 0, 0, 0},  {&_swigt__p_SoGLVertexAttributeElement, _p_SoGLVertexAttributeElementTo_p_SoVertexAttributeElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexProperty[] = {  {&_swigt__p_SoVertexProperty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexShader[] = {  {&_swigt__p_SoVertexShader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVertexShape[] = {  {&_swigt__p_SoVertexShape, 0, 0, 0},  {&_swigt__p_SoFaceSet, _p_SoFaceSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedFaceSet, _p_SoIndexedFaceSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedLineSet, _p_SoIndexedLineSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedMarkerSet, _p_SoIndexedMarkerSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedPointSet, _p_SoIndexedPointSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedShape, _p_SoIndexedShapeTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoIndexedTriangleStripSet, _p_SoIndexedTriangleStripSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoLineSet, _p_SoLineSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoMarkerSet, _p_SoMarkerSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoNonIndexedShape, _p_SoNonIndexedShapeTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoPointSet, _p_SoPointSetTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoQuadMesh, _p_SoQuadMeshTo_p_SoVertexShape, 0, 0},  {&_swigt__p_SoTriangleStripSet, _p_SoTriangleStripSetTo_p_SoVertexShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoViewVolumeElement[] = {  {&_swigt__p_SoViewVolumeElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoViewingMatrixElement[] = {  {&_swigt__p_SoViewingMatrixElement, 0, 0, 0},  {&_swigt__p_SoGLViewingMatrixElement, _p_SoGLViewingMatrixElementTo_p_SoViewingMatrixElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoViewportRegionElement[] = {  {&_swigt__p_SoViewportRegionElement, 0, 0, 0},  {&_swigt__p_SoGLViewportRegionElement, _p_SoGLViewportRegionElementTo_p_SoViewportRegionElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoWWWAnchor[] = {  {&_swigt__p_SoWWWAnchor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoWWWInline[] = {  {&_swigt__p_SoWWWInline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoWindowElement[] = {  {&_swigt__p_SoWindowElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoWrapperKit[] = {  {&_swigt__p_SoWrapperKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoWriteAction[] = {  {&_swigt__p_SoWriteAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__doublep[] = {{&_swigt__p_a_2__doublep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__double[] = {  {&_swigt__p_a_2__double, 0, 0, 0},  {&_swigt__p_a_2__doublep, _p_a_2__doublepTo_p_a_2__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__intp[] = {{&_swigt__p_a_2__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__int[] = {  {&_swigt__p_a_2__int, 0, 0, 0},  {&_swigt__p_a_2__intp, _p_a_2__intpTo_p_a_2__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__short[] = {  {&_swigt__p_a_2__short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__signed_char[] = {  {&_swigt__p_a_2__signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__intp[] = {{&_swigt__p_a_3__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__int[] = {  {&_swigt__p_a_3__int, 0, 0, 0},  {&_swigt__p_a_3__intp, _p_a_3__intpTo_p_a_3__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__short[] = {  {&_swigt__p_a_3__short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__signed_char[] = {  {&_swigt__p_a_3__signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__a_4__doublep[] = {{&_swigt__p_a_4__a_4__doublep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__a_4__double[] = {  {&_swigt__p_a_4__a_4__double, 0, 0, 0},  {&_swigt__p_a_4__a_4__doublep, _p_a_4__a_4__doublepTo_p_a_4__a_4__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__a_4__floatp[] = {{&_swigt__p_a_4__a_4__floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__a_4__float[] = {  {&_swigt__p_a_4__a_4__float, 0, 0, 0},  {&_swigt__p_a_4__a_4__floatp, _p_a_4__a_4__floatpTo_p_a_4__a_4__float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__doublep[] = {{&_swigt__p_a_4__doublep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__double[] = {  {&_swigt__p_a_4__double, 0, 0, 0},  {&_swigt__p_a_4__doublep, _p_a_4__doublepTo_p_a_4__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__floatp[] = {{&_swigt__p_a_4__floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__float[] = {  {&_swigt__p_a_4__float, 0, 0, 0},  {&_swigt__p_a_4__floatp, _p_a_4__floatpTo_p_a_4__float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__intp[] = {{&_swigt__p_a_4__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__int[] = {  {&_swigt__p_a_4__int, 0, 0, 0},  {&_swigt__p_a_4__intp, _p_a_4__intpTo_p_a_4__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__short[] = {  {&_swigt__p_a_4__short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__signed_char[] = {  {&_swigt__p_a_4__signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__unsigned_char[] = {  {&_swigt__p_a_4__unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__unsigned_int[] = {  {&_swigt__p_a_4__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__unsigned_short[] = {  {&_swigt__p_a_4__unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cc_glglue[] = {  {&_swigt__p_cc_glglue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cc_storage_f[] = {  {&_swigt__p_cc_storage_f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cc_xml_doc[] = {  {&_swigt__p_cc_xml_doc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_cc_xml_elt[] = {  {&_swigt__p_cc_xml_elt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},  {&_swigt__p_charp, _p_charpTo_p_char, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_charp[] = {  {&_swigt__p_charp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_close_func[] = {  {&_swigt__p_close_func, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},  {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_doublep[] = {  {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_char__charp[] = {{&_swigt__p_f_char__charp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_char__char[] = {  {&_swigt__p_f_char__char, 0, 0, 0},  {&_swigt__p_f_char__charp, _p_f_char__charpTo_p_f_char__char, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_float_p_void__intp[] = {{&_swigt__p_f_float_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_float_p_void__int[] = {  {&_swigt__p_f_float_p_void__int, 0, 0, 0},  {&_swigt__p_f_float_p_void__intp, _p_f_float_p_void__intpTo_p_f_float_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_SoAction_p_SoNode__void[] = {  {&_swigt__p_f_p_SoAction_p_SoNode__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto[] = {  {&_swigt__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp[] = {{&_swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int[] = {  {&_swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int, 0, 0, 0},  {&_swigt__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp, _p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intpTo_p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__SoError_p_void__void[] = {  {&_swigt__p_f_p_q_const__SoError_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__SoGLRenderAction__AbortCode[] = {  {&_swigt__p_f_p_void__SoGLRenderAction__AbortCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__floatp[] = {{&_swigt__p_f_p_void__floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__float[] = {  {&_swigt__p_f_p_void__float, 0, 0, 0},  {&_swigt__p_f_p_void__floatp, _p_f_p_void__floatpTo_p_f_p_void__float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__intp[] = {{&_swigt__p_f_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__int[] = {  {&_swigt__p_f_p_void__int, 0, 0, 0},  {&_swigt__p_f_p_void__intp, _p_f_p_void__intpTo_p_f_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__p_void[] = {  {&_swigt__p_f_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__void[] = {  {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_int__void[] = {  {&_swigt__p_f_p_void_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp[] = {{&_swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int[] = {  {&_swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int, 0, 0, 0},  {&_swigt__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp, _p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intpTo_p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_ScXMLStateMachine__void[] = {  {&_swigt__p_f_p_void_p_ScXMLStateMachine__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void[] = {  {&_swigt__p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void[] = {  {&_swigt__p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoAction__void[] = {  {&_swigt__p_f_p_void_p_SoAction__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp[] = {{&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp, _p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp[] = {{&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp, _p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp[] = {{&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp, _p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intpTo_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void[] = {  {&_swigt__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoDragger__void[] = {  {&_swigt__p_f_p_void_p_SoDragger__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoEventCallback__void[] = {  {&_swigt__p_f_p_void_p_SoEventCallback__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoGLRenderAction__floatp[] = {{&_swigt__p_f_p_void_p_SoGLRenderAction__floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoGLRenderAction__float[] = {  {&_swigt__p_f_p_void_p_SoGLRenderAction__float, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoGLRenderAction__floatp, _p_f_p_void_p_SoGLRenderAction__floatpTo_p_f_p_void_p_SoGLRenderAction__float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoGLRenderAction__void[] = {  {&_swigt__p_f_p_void_p_SoGLRenderAction__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoInput__void[] = {  {&_swigt__p_f_p_void_p_SoInput__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoPath__void[] = {  {&_swigt__p_f_p_void_p_SoPath__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoRenderManager__void[] = {  {&_swigt__p_f_p_void_p_SoRenderManager__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoSceneManager__void[] = {  {&_swigt__p_f_p_void_p_SoSceneManager__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoSelection__void[] = {  {&_swigt__p_f_p_void_p_SoSelection__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoSensor__void[] = {  {&_swigt__p_f_p_void_p_SoSensor__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoState_q_const__int__void[] = {  {&_swigt__p_f_p_void_p_SoState_q_const__int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__intp[] = {{&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__int[] = {  {&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__intp, _p_f_p_void_p_SoVRMLAudioClip_p_void__intpTo_p_f_p_void_p_SoVRMLAudioClip_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__longp[] = {{&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__longp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__long[] = {  {&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__long, 0, 0, 0},  {&_swigt__p_f_p_void_p_SoVRMLAudioClip_p_void__longp, _p_f_p_void_p_SoVRMLAudioClip_p_void__longpTo_p_f_p_void_p_SoVRMLAudioClip_p_void__long, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoVRMLScript__void[] = {  {&_swigt__p_f_p_void_p_SoVRMLScript__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp[] = {  {&_swigt__p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response[] = {  {&_swigt__p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath__p_SoFullPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPath__p_SoFullPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath__p_SoTempPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPath__p_SoTempPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath__p_SoPath[] = {  {&_swigt__p_f_p_void_p_q_const__SoPath__p_SoPath, 0, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPath__p_SoFullPath, _p_f_p_void_p_q_const__SoPath__p_SoFullPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath, _p_f_p_void_p_q_const__SoPath__p_SoNodeKitPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPath__p_SoTempPath, _p_f_p_void_p_q_const__SoPath__p_SoTempPathTo_p_f_p_void_p_q_const__SoPath__p_SoPath, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp[] = {{&_swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int[] = {  {&_swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp, _p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intpTo_p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath[] = {{&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoPath[] = {  {&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoPath, 0, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath, _p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath, _p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath, 0, 0},  {&_swigt__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath, _p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPathTo_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void__intp[] = {{&_swigt__p_f_p_void_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void__int[] = {  {&_swigt__p_f_p_void_p_void__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_void__intp, _p_f_p_void_p_void__intpTo_p_f_p_void_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void__void[] = {  {&_swigt__p_f_p_void_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t[] = {  {&_swigt__p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void_p_void_p_void__void[] = {  {&_swigt__p_f_p_void_p_void_p_void_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f[] = {{&_swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f[] = {  {&_swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f, 0, 0, 0},  {&_swigt__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f, _p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4fTo_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_size_t__p_void[] = {  {&_swigt__p_f_p_void_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_unsigned_int__void[] = {  {&_swigt__p_f_p_void_unsigned_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp[] = {{&_swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int[] = {  {&_swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int, 0, 0, 0},  {&_swigt__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp, _p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intpTo_p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbBox3f__intp[] = {{&_swigt__p_f_q_const__p_void_r_q_const__SbBox3f__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbBox3f__int[] = {  {&_swigt__p_f_q_const__p_void_r_q_const__SbBox3f__int, 0, 0, 0},  {&_swigt__p_f_q_const__p_void_r_q_const__SbBox3f__intp, _p_f_q_const__p_void_r_q_const__SbBox3f__intpTo_p_f_q_const__p_void_r_q_const__SbBox3f__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbSphere__intp[] = {{&_swigt__p_f_q_const__p_void_r_q_const__SbSphere__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbSphere__int[] = {  {&_swigt__p_f_q_const__p_void_r_q_const__SbSphere__int, 0, 0, 0},  {&_swigt__p_f_q_const__p_void_r_q_const__SbSphere__intp, _p_f_q_const__p_void_r_q_const__SbSphere__intpTo_p_f_q_const__p_void_r_q_const__SbSphere__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbVec3f__intp[] = {{&_swigt__p_f_q_const__p_void_r_q_const__SbVec3f__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__p_void_r_q_const__SbVec3f__int[] = {  {&_swigt__p_f_q_const__p_void_r_q_const__SbVec3f__int, 0, 0, 0},  {&_swigt__p_f_q_const__p_void_r_q_const__SbVec3f__intp, _p_f_q_const__p_void_r_q_const__SbVec3f__intpTo_p_f_q_const__p_void_r_q_const__SbVec3f__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_q_const__unsigned_int__unsigned_int[] = {  {&_swigt__p_f_q_const__unsigned_int__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbName_float_int_p_void__intp[] = {{&_swigt__p_f_r_q_const__SbName_float_int_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbName_float_int_p_void__int[] = {  {&_swigt__p_f_r_q_const__SbName_float_int_p_void__int, 0, 0, 0},  {&_swigt__p_f_r_q_const__SbName_float_int_p_void__intp, _p_f_r_q_const__SbName_float_int_p_void__intpTo_p_f_r_q_const__SbName_float_int_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void[] = {  {&_swigt__p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_SbImage_p_void__intp[] = {{&_swigt__p_f_r_q_const__SbString_p_SbImage_p_void__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_SbImage_p_void__int[] = {  {&_swigt__p_f_r_q_const__SbString_p_SbImage_p_void__int, 0, 0, 0},  {&_swigt__p_f_r_q_const__SbString_p_SbImage_p_void__intp, _p_f_r_q_const__SbString_p_SbImage_p_void__intpTo_p_f_r_q_const__SbString_p_SbImage_p_void__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void[] = {  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp[] = {{&_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int[] = {  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int, 0, 0, 0},  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp, _p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intpTo_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void[] = {  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void[] = {  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbString_p_void_p_SoWWWInline__void[] = {  {&_swigt__p_f_r_q_const__SbString_p_void_p_SoWWWInline__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void[] = {  {&_swigt__p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void[] = {  {&_swigt__p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_int_p_void__void[] = {  {&_swigt__p_f_unsigned_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_int_p_void_p_void__void[] = {  {&_swigt__p_f_unsigned_int_p_void_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_void__p_void[] = {  {&_swigt__p_f_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},  {&_swigt__p_floatp, _p_floatpTo_p_float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_floatp[] = {  {&_swigt__p_floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},  {&_swigt__p_intp, _p_intpTo_p_int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_intp[] = {  {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},  {&_swigt__p_longp, _p_longpTo_p_long, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_longp[] = {  {&_swigt__p_longp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_open_func[] = {  {&_swigt__p_open_func, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SbName[] = {  {&_swigt__p_p_SbName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SbString[] = {  {&_swigt__p_p_SbString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SbVec2f[] = {  {&_swigt__p_p_SbVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLAddOpExprDataObj[] = {{&_swigt__p_p_ScXMLAddOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLAndOpExprDataObj[] = {{&_swigt__p_p_ScXMLAndOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLAppendOpExprDataObj[] = {{&_swigt__p_p_ScXMLAppendOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLBoolDataObj[] = {{&_swigt__p_p_ScXMLBoolDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinAddOpExprDataObj[] = {{&_swigt__p_p_ScXMLCoinAddOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinDivideOpExprDataObj[] = {{&_swigt__p_p_ScXMLCoinDivideOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinEqualsOpExprDataObj[] = {{&_swigt__p_p_ScXMLCoinEqualsOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinLengthFuncExprDataObj[] = {{&_swigt__p_p_ScXMLCoinLengthFuncExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinMultiplyOpExprDataObj[] = {{&_swigt__p_p_ScXMLCoinMultiplyOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLCoinSubtractOpExprDataObj[] = {{&_swigt__p_p_ScXMLCoinSubtractOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLConstantDataObj[] = {{&_swigt__p_p_ScXMLConstantDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLDivideOpExprDataObj[] = {{&_swigt__p_p_ScXMLDivideOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLEqualsOpExprDataObj[] = {{&_swigt__p_p_ScXMLEqualsOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLExprDataObj[] = {{&_swigt__p_p_ScXMLExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLInExprDataObj[] = {{&_swigt__p_p_ScXMLInExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLMinimumExprDataObj[] = {{&_swigt__p_p_ScXMLMinimumExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLMultiplyOpExprDataObj[] = {{&_swigt__p_p_ScXMLMultiplyOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLNegateOpExprDataObj[] = {{&_swigt__p_p_ScXMLNegateOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLNotOpExprDataObj[] = {{&_swigt__p_p_ScXMLNotOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLOrOpExprDataObj[] = {{&_swigt__p_p_ScXMLOrOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLRealDataObj[] = {{&_swigt__p_p_ScXMLRealDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLReferenceDataObj[] = {{&_swigt__p_p_ScXMLReferenceDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLSbDataObj[] = {{&_swigt__p_p_ScXMLSbDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLStringDataObj[] = {{&_swigt__p_p_ScXMLStringDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLSubtractOpExprDataObj[] = {{&_swigt__p_p_ScXMLSubtractOpExprDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLXMLDataObj[] = {{&_swigt__p_p_ScXMLXMLDataObj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ScXMLDataObj[] = {  {&_swigt__p_p_ScXMLDataObj, 0, 0, 0},  {&_swigt__p_p_ScXMLAddOpExprDataObj, _p_p_ScXMLAddOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLAndOpExprDataObj, _p_p_ScXMLAndOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLAppendOpExprDataObj, _p_p_ScXMLAppendOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLBoolDataObj, _p_p_ScXMLBoolDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinAddOpExprDataObj, _p_p_ScXMLCoinAddOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinDivideOpExprDataObj, _p_p_ScXMLCoinDivideOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinEqualsOpExprDataObj, _p_p_ScXMLCoinEqualsOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinLengthFuncExprDataObj, _p_p_ScXMLCoinLengthFuncExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinMultiplyOpExprDataObj, _p_p_ScXMLCoinMultiplyOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLCoinSubtractOpExprDataObj, _p_p_ScXMLCoinSubtractOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLConstantDataObj, _p_p_ScXMLConstantDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLDivideOpExprDataObj, _p_p_ScXMLDivideOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLEqualsOpExprDataObj, _p_p_ScXMLEqualsOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLExprDataObj, _p_p_ScXMLExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLInExprDataObj, _p_p_ScXMLInExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLMinimumExprDataObj, _p_p_ScXMLMinimumExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLMultiplyOpExprDataObj, _p_p_ScXMLMultiplyOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLNegateOpExprDataObj, _p_p_ScXMLNegateOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLNotOpExprDataObj, _p_p_ScXMLNotOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLOrOpExprDataObj, _p_p_ScXMLOrOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLRealDataObj, _p_p_ScXMLRealDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLReferenceDataObj, _p_p_ScXMLReferenceDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLSbDataObj, _p_p_ScXMLSbDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLStringDataObj, _p_p_ScXMLStringDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLSubtractOpExprDataObj, _p_p_ScXMLSubtractOpExprDataObjTo_p_p_ScXMLDataObj, 0, 0},  {&_swigt__p_p_ScXMLXMLDataObj, _p_p_ScXMLXMLDataObjTo_p_p_ScXMLDataObj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoAlphaTest[] = {{&_swigt__p_p_SoAlphaTest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoAnnotation[] = {{&_swigt__p_p_SoAnnotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoAntiSquish[] = {{&_swigt__p_p_SoAntiSquish, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoAppearanceKit[] = {{&_swigt__p_p_SoAppearanceKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoArray[] = {{&_swigt__p_p_SoArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoAsciiText[] = {{&_swigt__p_p_SoAsciiText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBaseColor[] = {{&_swigt__p_p_SoBaseColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBaseKit[] = {{&_swigt__p_p_SoBaseKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBlinker[] = {{&_swigt__p_p_SoBlinker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBoolOperation[] = {{&_swigt__p_p_SoBoolOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBumpMap[] = {{&_swigt__p_p_SoBumpMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBumpMapCoordinate[] = {{&_swigt__p_p_SoBumpMapCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBumpMapTransform[] = {{&_swigt__p_p_SoBumpMapTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCacheHint[] = {{&_swigt__p_p_SoCacheHint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCalculator[] = {{&_swigt__p_p_SoCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCallback[] = {{&_swigt__p_p_SoCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCamera[] = {{&_swigt__p_p_SoCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCameraKit[] = {{&_swigt__p_p_SoCameraKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCenterballDragger[] = {{&_swigt__p_p_SoCenterballDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCenterballManip[] = {{&_swigt__p_p_SoCenterballManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoClipPlane[] = {{&_swigt__p_p_SoClipPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoClipPlaneManip[] = {{&_swigt__p_p_SoClipPlaneManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoColorIndex[] = {{&_swigt__p_p_SoColorIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComplexity[] = {{&_swigt__p_p_SoComplexity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeMatrix[] = {{&_swigt__p_p_SoComposeMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeRotation[] = {{&_swigt__p_p_SoComposeRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeRotationFromTo[] = {{&_swigt__p_p_SoComposeRotationFromTo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeVec2f[] = {{&_swigt__p_p_SoComposeVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeVec3f[] = {{&_swigt__p_p_SoComposeVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComposeVec4f[] = {{&_swigt__p_p_SoComposeVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoComputeBoundingBox[] = {{&_swigt__p_p_SoComputeBoundingBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoConcatenate[] = {{&_swigt__p_p_SoConcatenate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCone[] = {{&_swigt__p_p_SoCone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCoordinate3[] = {{&_swigt__p_p_SoCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCoordinate4[] = {{&_swigt__p_p_SoCoordinate4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCounter[] = {{&_swigt__p_p_SoCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCube[] = {{&_swigt__p_p_SoCube, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoCylinder[] = {{&_swigt__p_p_SoCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDecomposeMatrix[] = {{&_swigt__p_p_SoDecomposeMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDecomposeRotation[] = {{&_swigt__p_p_SoDecomposeRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDecomposeVec2f[] = {{&_swigt__p_p_SoDecomposeVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDecomposeVec3f[] = {{&_swigt__p_p_SoDecomposeVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDecomposeVec4f[] = {{&_swigt__p_p_SoDecomposeVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDepthBuffer[] = {{&_swigt__p_p_SoDepthBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDirectionalLight[] = {{&_swigt__p_p_SoDirectionalLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDirectionalLightDragger[] = {{&_swigt__p_p_SoDirectionalLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDirectionalLightManip[] = {{&_swigt__p_p_SoDirectionalLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDragPointDragger[] = {{&_swigt__p_p_SoDragPointDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDragger[] = {{&_swigt__p_p_SoDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoDrawStyle[] = {{&_swigt__p_p_SoDrawStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoElapsedTime[] = {{&_swigt__p_p_SoElapsedTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoEnvironment[] = {{&_swigt__p_p_SoEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoEventCallback[] = {{&_swigt__p_p_SoEventCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoExtSelection[] = {{&_swigt__p_p_SoExtSelection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFaceSet[] = {{&_swigt__p_p_SoFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFieldContainer[] = {{&_swigt__p_p_SoFieldContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFieldConverter[] = {{&_swigt__p_p_SoFieldConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFile[] = {{&_swigt__p_p_SoFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFont[] = {{&_swigt__p_p_SoFont, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFontStyle[] = {{&_swigt__p_p_SoFontStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFragmentShader[] = {{&_swigt__p_p_SoFragmentShader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFrustumCamera[] = {{&_swigt__p_p_SoFrustumCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoFullPath[] = {{&_swigt__p_p_SoFullPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGate[] = {{&_swigt__p_p_SoGate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGeoCoordinate[] = {{&_swigt__p_p_SoGeoCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGeoLocation[] = {{&_swigt__p_p_SoGeoLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGeoOrigin[] = {{&_swigt__p_p_SoGeoOrigin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGeoSeparator[] = {{&_swigt__p_p_SoGeoSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGroup[] = {{&_swigt__p_p_SoGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoHandleBoxDragger[] = {{&_swigt__p_p_SoHandleBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoHandleBoxManip[] = {{&_swigt__p_p_SoHandleBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoHeightMapToNormalMap[] = {{&_swigt__p_p_SoHeightMapToNormalMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoImage[] = {{&_swigt__p_p_SoImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedFaceSet[] = {{&_swigt__p_p_SoIndexedFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedLineSet[] = {{&_swigt__p_p_SoIndexedLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedMarkerSet[] = {{&_swigt__p_p_SoIndexedMarkerSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedNurbsCurve[] = {{&_swigt__p_p_SoIndexedNurbsCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedNurbsSurface[] = {{&_swigt__p_p_SoIndexedNurbsSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedPointSet[] = {{&_swigt__p_p_SoIndexedPointSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedShape[] = {{&_swigt__p_p_SoIndexedShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoIndexedTriangleStripSet[] = {{&_swigt__p_p_SoIndexedTriangleStripSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInfo[] = {{&_swigt__p_p_SoInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInteractionKit[] = {{&_swigt__p_p_SoInteractionKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolate[] = {{&_swigt__p_p_SoInterpolate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolateFloat[] = {{&_swigt__p_p_SoInterpolateFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolateRotation[] = {{&_swigt__p_p_SoInterpolateRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolateVec2f[] = {{&_swigt__p_p_SoInterpolateVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolateVec3f[] = {{&_swigt__p_p_SoInterpolateVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoInterpolateVec4f[] = {{&_swigt__p_p_SoInterpolateVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoJackDragger[] = {{&_swigt__p_p_SoJackDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoJackManip[] = {{&_swigt__p_p_SoJackManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLOD[] = {{&_swigt__p_p_SoLOD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLabel[] = {{&_swigt__p_p_SoLabel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLevelOfDetail[] = {{&_swigt__p_p_SoLevelOfDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLight[] = {{&_swigt__p_p_SoLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLightKit[] = {{&_swigt__p_p_SoLightKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLightModel[] = {{&_swigt__p_p_SoLightModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLineSet[] = {{&_swigt__p_p_SoLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLinearProfile[] = {{&_swigt__p_p_SoLinearProfile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoListener[] = {{&_swigt__p_p_SoListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLocateHighlight[] = {{&_swigt__p_p_SoLocateHighlight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMarkerSet[] = {{&_swigt__p_p_SoMarkerSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMaterial[] = {{&_swigt__p_p_SoMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMaterialBinding[] = {{&_swigt__p_p_SoMaterialBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMatrixTransform[] = {{&_swigt__p_p_SoMatrixTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMultipleCopy[] = {{&_swigt__p_p_SoMultipleCopy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNodeEngine[] = {{&_swigt__p_p_SoNodeEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNodeKitListPart[] = {{&_swigt__p_p_SoNodeKitListPart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNodeKitPath[] = {{&_swigt__p_p_SoNodeKitPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNonIndexedShape[] = {{&_swigt__p_p_SoNonIndexedShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNormal[] = {{&_swigt__p_p_SoNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNormalBinding[] = {{&_swigt__p_p_SoNormalBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNurbsCurve[] = {{&_swigt__p_p_SoNurbsCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNurbsProfile[] = {{&_swigt__p_p_SoNurbsProfile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNurbsSurface[] = {{&_swigt__p_p_SoNurbsSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoOnOff[] = {{&_swigt__p_p_SoOnOff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoOneShot[] = {{&_swigt__p_p_SoOneShot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoOrthographicCamera[] = {{&_swigt__p_p_SoOrthographicCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPackedColor[] = {{&_swigt__p_p_SoPackedColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPathSwitch[] = {{&_swigt__p_p_SoPathSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPendulum[] = {{&_swigt__p_p_SoPendulum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPerspectiveCamera[] = {{&_swigt__p_p_SoPerspectiveCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPickStyle[] = {{&_swigt__p_p_SoPickStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPointLight[] = {{&_swigt__p_p_SoPointLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPointLightDragger[] = {{&_swigt__p_p_SoPointLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPointLightManip[] = {{&_swigt__p_p_SoPointLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPointSet[] = {{&_swigt__p_p_SoPointSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPolygonOffset[] = {{&_swigt__p_p_SoPolygonOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoProfile[] = {{&_swigt__p_p_SoProfile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoProfileCoordinate2[] = {{&_swigt__p_p_SoProfileCoordinate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoProfileCoordinate3[] = {{&_swigt__p_p_SoProfileCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoProto[] = {{&_swigt__p_p_SoProto, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoProtoInstance[] = {{&_swigt__p_p_SoProtoInstance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoQuadMesh[] = {{&_swigt__p_p_SoQuadMesh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoResetTransform[] = {{&_swigt__p_p_SoResetTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoReversePerspectiveCamera[] = {{&_swigt__p_p_SoReversePerspectiveCamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotateCylindricalDragger[] = {{&_swigt__p_p_SoRotateCylindricalDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotateDiscDragger[] = {{&_swigt__p_p_SoRotateDiscDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotateSphericalDragger[] = {{&_swigt__p_p_SoRotateSphericalDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotation[] = {{&_swigt__p_p_SoRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotationXYZ[] = {{&_swigt__p_p_SoRotationXYZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoRotor[] = {{&_swigt__p_p_SoRotor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoScale[] = {{&_swigt__p_p_SoScale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoScale1Dragger[] = {{&_swigt__p_p_SoScale1Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoScale2Dragger[] = {{&_swigt__p_p_SoScale2Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoScale2UniformDragger[] = {{&_swigt__p_p_SoScale2UniformDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoScaleUniformDragger[] = {{&_swigt__p_p_SoScaleUniformDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSceneKit[] = {{&_swigt__p_p_SoSceneKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSceneTexture2[] = {{&_swigt__p_p_SoSceneTexture2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSceneTextureCubeMap[] = {{&_swigt__p_p_SoSceneTextureCubeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSelectOne[] = {{&_swigt__p_p_SoSelectOne, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSelection[] = {{&_swigt__p_p_SoSelection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSeparator[] = {{&_swigt__p_p_SoSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSeparatorKit[] = {{&_swigt__p_p_SoSeparatorKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderObject[] = {{&_swigt__p_p_SoShaderObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter[] = {{&_swigt__p_p_SoShaderParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter1f[] = {{&_swigt__p_p_SoShaderParameter1f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter1i[] = {{&_swigt__p_p_SoShaderParameter1i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter2f[] = {{&_swigt__p_p_SoShaderParameter2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter2i[] = {{&_swigt__p_p_SoShaderParameter2i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter3f[] = {{&_swigt__p_p_SoShaderParameter3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter3i[] = {{&_swigt__p_p_SoShaderParameter3i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter4f[] = {{&_swigt__p_p_SoShaderParameter4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameter4i[] = {{&_swigt__p_p_SoShaderParameter4i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray1f[] = {{&_swigt__p_p_SoShaderParameterArray1f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray1i[] = {{&_swigt__p_p_SoShaderParameterArray1i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray2f[] = {{&_swigt__p_p_SoShaderParameterArray2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray2i[] = {{&_swigt__p_p_SoShaderParameterArray2i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray3f[] = {{&_swigt__p_p_SoShaderParameterArray3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray3i[] = {{&_swigt__p_p_SoShaderParameterArray3i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray4f[] = {{&_swigt__p_p_SoShaderParameterArray4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterArray4i[] = {{&_swigt__p_p_SoShaderParameterArray4i, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterMatrix[] = {{&_swigt__p_p_SoShaderParameterMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderParameterMatrixArray[] = {{&_swigt__p_p_SoShaderParameterMatrixArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderProgram[] = {{&_swigt__p_p_SoShaderProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShaderStateMatrixParameter[] = {{&_swigt__p_p_SoShaderStateMatrixParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShape[] = {{&_swigt__p_p_SoShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShapeHints[] = {{&_swigt__p_p_SoShapeHints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShapeKit[] = {{&_swigt__p_p_SoShapeKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoShuttle[] = {{&_swigt__p_p_SoShuttle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSphere[] = {{&_swigt__p_p_SoSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSpotLight[] = {{&_swigt__p_p_SoSpotLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSpotLightDragger[] = {{&_swigt__p_p_SoSpotLightDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSpotLightManip[] = {{&_swigt__p_p_SoSpotLightManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSurroundScale[] = {{&_swigt__p_p_SoSurroundScale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSwitch[] = {{&_swigt__p_p_SoSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTabBoxDragger[] = {{&_swigt__p_p_SoTabBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTabBoxManip[] = {{&_swigt__p_p_SoTabBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTabPlaneDragger[] = {{&_swigt__p_p_SoTabPlaneDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTempPath[] = {{&_swigt__p_p_SoTempPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoText2[] = {{&_swigt__p_p_SoText2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoText3[] = {{&_swigt__p_p_SoText3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture[] = {{&_swigt__p_p_SoTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture2[] = {{&_swigt__p_p_SoTexture2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture2Convert[] = {{&_swigt__p_p_SoTexture2Convert, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture2Transform[] = {{&_swigt__p_p_SoTexture2Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture3[] = {{&_swigt__p_p_SoTexture3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTexture3Transform[] = {{&_swigt__p_p_SoTexture3Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCombine[] = {{&_swigt__p_p_SoTextureCombine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinate2[] = {{&_swigt__p_p_SoTextureCoordinate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinate3[] = {{&_swigt__p_p_SoTextureCoordinate3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateBinding[] = {{&_swigt__p_p_SoTextureCoordinateBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateCube[] = {{&_swigt__p_p_SoTextureCoordinateCube, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateCylinder[] = {{&_swigt__p_p_SoTextureCoordinateCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateDefault[] = {{&_swigt__p_p_SoTextureCoordinateDefault, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateEnvironment[] = {{&_swigt__p_p_SoTextureCoordinateEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateFunction[] = {{&_swigt__p_p_SoTextureCoordinateFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateNormalMap[] = {{&_swigt__p_p_SoTextureCoordinateNormalMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateObject[] = {{&_swigt__p_p_SoTextureCoordinateObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinatePlane[] = {{&_swigt__p_p_SoTextureCoordinatePlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateReflectionMap[] = {{&_swigt__p_p_SoTextureCoordinateReflectionMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCoordinateSphere[] = {{&_swigt__p_p_SoTextureCoordinateSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureCubeMap[] = {{&_swigt__p_p_SoTextureCubeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureMatrixTransform[] = {{&_swigt__p_p_SoTextureMatrixTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureScalePolicy[] = {{&_swigt__p_p_SoTextureScalePolicy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTextureUnit[] = {{&_swigt__p_p_SoTextureUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTimeCounter[] = {{&_swigt__p_p_SoTimeCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTrackballDragger[] = {{&_swigt__p_p_SoTrackballDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTrackballManip[] = {{&_swigt__p_p_SoTrackballManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransform[] = {{&_swigt__p_p_SoTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformBoxDragger[] = {{&_swigt__p_p_SoTransformBoxDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformBoxManip[] = {{&_swigt__p_p_SoTransformBoxManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformManip[] = {{&_swigt__p_p_SoTransformManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformSeparator[] = {{&_swigt__p_p_SoTransformSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformVec3f[] = {{&_swigt__p_p_SoTransformVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformation[] = {{&_swigt__p_p_SoTransformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformerDragger[] = {{&_swigt__p_p_SoTransformerDragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransformerManip[] = {{&_swigt__p_p_SoTransformerManip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTranslate1Dragger[] = {{&_swigt__p_p_SoTranslate1Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTranslate2Dragger[] = {{&_swigt__p_p_SoTranslate2Dragger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTranslation[] = {{&_swigt__p_p_SoTranslation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTransparencyType[] = {{&_swigt__p_p_SoTransparencyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTriangleStripSet[] = {{&_swigt__p_p_SoTriangleStripSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoTriggerAny[] = {{&_swigt__p_p_SoTriggerAny, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoUniformShaderParameter[] = {{&_swigt__p_p_SoUniformShaderParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoUnits[] = {{&_swigt__p_p_SoUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLAnchor[] = {{&_swigt__p_p_SoVRMLAnchor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLAppearance[] = {{&_swigt__p_p_SoVRMLAppearance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLAudioClip[] = {{&_swigt__p_p_SoVRMLAudioClip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLBackground[] = {{&_swigt__p_p_SoVRMLBackground, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLBillboard[] = {{&_swigt__p_p_SoVRMLBillboard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLBox[] = {{&_swigt__p_p_SoVRMLBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCollision[] = {{&_swigt__p_p_SoVRMLCollision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLColor[] = {{&_swigt__p_p_SoVRMLColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLColorInterpolator[] = {{&_swigt__p_p_SoVRMLColorInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCone[] = {{&_swigt__p_p_SoVRMLCone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCoordinate[] = {{&_swigt__p_p_SoVRMLCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCoordinateInterpolator[] = {{&_swigt__p_p_SoVRMLCoordinateInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCylinder[] = {{&_swigt__p_p_SoVRMLCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLCylinderSensor[] = {{&_swigt__p_p_SoVRMLCylinderSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLDirectionalLight[] = {{&_swigt__p_p_SoVRMLDirectionalLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLDragSensor[] = {{&_swigt__p_p_SoVRMLDragSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLElevationGrid[] = {{&_swigt__p_p_SoVRMLElevationGrid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLExtrusion[] = {{&_swigt__p_p_SoVRMLExtrusion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLFog[] = {{&_swigt__p_p_SoVRMLFog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLFontStyle[] = {{&_swigt__p_p_SoVRMLFontStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLGeometry[] = {{&_swigt__p_p_SoVRMLGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLGroup[] = {{&_swigt__p_p_SoVRMLGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLImageTexture[] = {{&_swigt__p_p_SoVRMLImageTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLIndexedFaceSet[] = {{&_swigt__p_p_SoVRMLIndexedFaceSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLIndexedLine[] = {{&_swigt__p_p_SoVRMLIndexedLine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLIndexedLineSet[] = {{&_swigt__p_p_SoVRMLIndexedLineSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLIndexedShape[] = {{&_swigt__p_p_SoVRMLIndexedShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLInline[] = {{&_swigt__p_p_SoVRMLInline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLInterpolator[] = {{&_swigt__p_p_SoVRMLInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLLOD[] = {{&_swigt__p_p_SoVRMLLOD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLLight[] = {{&_swigt__p_p_SoVRMLLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLMaterial[] = {{&_swigt__p_p_SoVRMLMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLMovieTexture[] = {{&_swigt__p_p_SoVRMLMovieTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLNavigationInfo[] = {{&_swigt__p_p_SoVRMLNavigationInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLNormal[] = {{&_swigt__p_p_SoVRMLNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLNormalInterpolator[] = {{&_swigt__p_p_SoVRMLNormalInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLOrientationInterpolator[] = {{&_swigt__p_p_SoVRMLOrientationInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLParent[] = {{&_swigt__p_p_SoVRMLParent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLPixelTexture[] = {{&_swigt__p_p_SoVRMLPixelTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLPlaneSensor[] = {{&_swigt__p_p_SoVRMLPlaneSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLPointLight[] = {{&_swigt__p_p_SoVRMLPointLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLPointSet[] = {{&_swigt__p_p_SoVRMLPointSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLPositionInterpolator[] = {{&_swigt__p_p_SoVRMLPositionInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLProximitySensor[] = {{&_swigt__p_p_SoVRMLProximitySensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLScalarInterpolator[] = {{&_swigt__p_p_SoVRMLScalarInterpolator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLScript[] = {{&_swigt__p_p_SoVRMLScript, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSensor[] = {{&_swigt__p_p_SoVRMLSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLShape[] = {{&_swigt__p_p_SoVRMLShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSound[] = {{&_swigt__p_p_SoVRMLSound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSphere[] = {{&_swigt__p_p_SoVRMLSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSphereSensor[] = {{&_swigt__p_p_SoVRMLSphereSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSpotLight[] = {{&_swigt__p_p_SoVRMLSpotLight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLSwitch[] = {{&_swigt__p_p_SoVRMLSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLText[] = {{&_swigt__p_p_SoVRMLText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTexture[] = {{&_swigt__p_p_SoVRMLTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTextureCoordinate[] = {{&_swigt__p_p_SoVRMLTextureCoordinate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTextureTransform[] = {{&_swigt__p_p_SoVRMLTextureTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTimeSensor[] = {{&_swigt__p_p_SoVRMLTimeSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTouchSensor[] = {{&_swigt__p_p_SoVRMLTouchSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLTransform[] = {{&_swigt__p_p_SoVRMLTransform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLVertexLine[] = {{&_swigt__p_p_SoVRMLVertexLine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLVertexPoint[] = {{&_swigt__p_p_SoVRMLVertexPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLVertexShape[] = {{&_swigt__p_p_SoVRMLVertexShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLViewpoint[] = {{&_swigt__p_p_SoVRMLViewpoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLVisibilitySensor[] = {{&_swigt__p_p_SoVRMLVisibilitySensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVRMLWorldInfo[] = {{&_swigt__p_p_SoVRMLWorldInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVertexAttribute[] = {{&_swigt__p_p_SoVertexAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVertexAttributeBinding[] = {{&_swigt__p_p_SoVertexAttributeBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVertexProperty[] = {{&_swigt__p_p_SoVertexProperty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVertexShader[] = {{&_swigt__p_p_SoVertexShader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoVertexShape[] = {{&_swigt__p_p_SoVertexShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoWWWAnchor[] = {{&_swigt__p_p_SoWWWAnchor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoWWWInline[] = {{&_swigt__p_p_SoWWWInline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoWrapperKit[] = {{&_swigt__p_p_SoWrapperKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBase[] = {  {&_swigt__p_p_SoBase, 0, 0, 0},  {&_swigt__p_p_SoAlphaTest, _p_p_SoAlphaTestTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoAnnotation, _p_p_SoAnnotationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoAntiSquish, _p_p_SoAntiSquishTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoAppearanceKit, _p_p_SoAppearanceKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoArray, _p_p_SoArrayTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoAsciiText, _p_p_SoAsciiTextTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBaseColor, _p_p_SoBaseColorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBaseKit, _p_p_SoBaseKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBlinker, _p_p_SoBlinkerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBoolOperation, _p_p_SoBoolOperationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBumpMap, _p_p_SoBumpMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBumpMapCoordinate, _p_p_SoBumpMapCoordinateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoBumpMapTransform, _p_p_SoBumpMapTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCacheHint, _p_p_SoCacheHintTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCalculator, _p_p_SoCalculatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCallback, _p_p_SoCallbackTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCamera, _p_p_SoCameraTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCameraKit, _p_p_SoCameraKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCenterballDragger, _p_p_SoCenterballDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCenterballManip, _p_p_SoCenterballManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoClipPlane, _p_p_SoClipPlaneTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoClipPlaneManip, _p_p_SoClipPlaneManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoColorIndex, _p_p_SoColorIndexTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComplexity, _p_p_SoComplexityTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeMatrix, _p_p_SoComposeMatrixTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeRotation, _p_p_SoComposeRotationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeRotationFromTo, _p_p_SoComposeRotationFromToTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeVec2f, _p_p_SoComposeVec2fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeVec3f, _p_p_SoComposeVec3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComposeVec4f, _p_p_SoComposeVec4fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoComputeBoundingBox, _p_p_SoComputeBoundingBoxTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoConcatenate, _p_p_SoConcatenateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCone, _p_p_SoConeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCoordinate3, _p_p_SoCoordinate3To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCoordinate4, _p_p_SoCoordinate4To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCounter, _p_p_SoCounterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCube, _p_p_SoCubeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoCylinder, _p_p_SoCylinderTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDecomposeMatrix, _p_p_SoDecomposeMatrixTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDecomposeRotation, _p_p_SoDecomposeRotationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDecomposeVec2f, _p_p_SoDecomposeVec2fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDecomposeVec3f, _p_p_SoDecomposeVec3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDecomposeVec4f, _p_p_SoDecomposeVec4fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDepthBuffer, _p_p_SoDepthBufferTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDirectionalLight, _p_p_SoDirectionalLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDirectionalLightDragger, _p_p_SoDirectionalLightDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDirectionalLightManip, _p_p_SoDirectionalLightManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDragPointDragger, _p_p_SoDragPointDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDragger, _p_p_SoDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoDrawStyle, _p_p_SoDrawStyleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoElapsedTime, _p_p_SoElapsedTimeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoEngine, _p_p_SoEngineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoEnvironment, _p_p_SoEnvironmentTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoEventCallback, _p_p_SoEventCallbackTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoExtSelection, _p_p_SoExtSelectionTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFaceSet, _p_p_SoFaceSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFieldContainer, _p_p_SoFieldContainerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFieldConverter, _p_p_SoFieldConverterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFile, _p_p_SoFileTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFont, _p_p_SoFontTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFontStyle, _p_p_SoFontStyleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFragmentShader, _p_p_SoFragmentShaderTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFrustumCamera, _p_p_SoFrustumCameraTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoFullPath, _p_p_SoFullPathTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGate, _p_p_SoGateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGeoCoordinate, _p_p_SoGeoCoordinateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGeoLocation, _p_p_SoGeoLocationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGeoOrigin, _p_p_SoGeoOriginTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGeoSeparator, _p_p_SoGeoSeparatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoGroup, _p_p_SoGroupTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoHandleBoxDragger, _p_p_SoHandleBoxDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoHandleBoxManip, _p_p_SoHandleBoxManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoHeightMapToNormalMap, _p_p_SoHeightMapToNormalMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoImage, _p_p_SoImageTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedFaceSet, _p_p_SoIndexedFaceSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedLineSet, _p_p_SoIndexedLineSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedMarkerSet, _p_p_SoIndexedMarkerSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedNurbsCurve, _p_p_SoIndexedNurbsCurveTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedNurbsSurface, _p_p_SoIndexedNurbsSurfaceTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedPointSet, _p_p_SoIndexedPointSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedShape, _p_p_SoIndexedShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoIndexedTriangleStripSet, _p_p_SoIndexedTriangleStripSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInfo, _p_p_SoInfoTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInteractionKit, _p_p_SoInteractionKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolate, _p_p_SoInterpolateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolateFloat, _p_p_SoInterpolateFloatTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolateRotation, _p_p_SoInterpolateRotationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolateVec2f, _p_p_SoInterpolateVec2fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolateVec3f, _p_p_SoInterpolateVec3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoInterpolateVec4f, _p_p_SoInterpolateVec4fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoJackDragger, _p_p_SoJackDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoJackManip, _p_p_SoJackManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLOD, _p_p_SoLODTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLabel, _p_p_SoLabelTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLevelOfDetail, _p_p_SoLevelOfDetailTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLight, _p_p_SoLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLightKit, _p_p_SoLightKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLightModel, _p_p_SoLightModelTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLineSet, _p_p_SoLineSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLinearProfile, _p_p_SoLinearProfileTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoListener, _p_p_SoListenerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoLocateHighlight, _p_p_SoLocateHighlightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoMarkerSet, _p_p_SoMarkerSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoMaterial, _p_p_SoMaterialTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoMaterialBinding, _p_p_SoMaterialBindingTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoMatrixTransform, _p_p_SoMatrixTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoMultipleCopy, _p_p_SoMultipleCopyTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNode, _p_p_SoNodeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNodeEngine, _p_p_SoNodeEngineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNodeKitListPart, _p_p_SoNodeKitListPartTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNodeKitPath, _p_p_SoNodeKitPathTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNonIndexedShape, _p_p_SoNonIndexedShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNormal, _p_p_SoNormalTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNormalBinding, _p_p_SoNormalBindingTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNurbsCurve, _p_p_SoNurbsCurveTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNurbsProfile, _p_p_SoNurbsProfileTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoNurbsSurface, _p_p_SoNurbsSurfaceTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoOnOff, _p_p_SoOnOffTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoOneShot, _p_p_SoOneShotTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoOrthographicCamera, _p_p_SoOrthographicCameraTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPackedColor, _p_p_SoPackedColorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPath, _p_p_SoPathTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPathSwitch, _p_p_SoPathSwitchTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPendulum, _p_p_SoPendulumTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPerspectiveCamera, _p_p_SoPerspectiveCameraTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPickStyle, _p_p_SoPickStyleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPointLight, _p_p_SoPointLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPointLightDragger, _p_p_SoPointLightDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPointLightManip, _p_p_SoPointLightManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPointSet, _p_p_SoPointSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoPolygonOffset, _p_p_SoPolygonOffsetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoProfile, _p_p_SoProfileTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoProfileCoordinate2, _p_p_SoProfileCoordinate2To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoProfileCoordinate3, _p_p_SoProfileCoordinate3To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoProto, _p_p_SoProtoTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoProtoInstance, _p_p_SoProtoInstanceTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoQuadMesh, _p_p_SoQuadMeshTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoResetTransform, _p_p_SoResetTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoReversePerspectiveCamera, _p_p_SoReversePerspectiveCameraTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotateCylindricalDragger, _p_p_SoRotateCylindricalDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotateDiscDragger, _p_p_SoRotateDiscDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotateSphericalDragger, _p_p_SoRotateSphericalDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotation, _p_p_SoRotationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotationXYZ, _p_p_SoRotationXYZTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoRotor, _p_p_SoRotorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoScale, _p_p_SoScaleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoScale1Dragger, _p_p_SoScale1DraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoScale2Dragger, _p_p_SoScale2DraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoScale2UniformDragger, _p_p_SoScale2UniformDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoScaleUniformDragger, _p_p_SoScaleUniformDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSceneKit, _p_p_SoSceneKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSceneTexture2, _p_p_SoSceneTexture2To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSceneTextureCubeMap, _p_p_SoSceneTextureCubeMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSelectOne, _p_p_SoSelectOneTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSelection, _p_p_SoSelectionTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSeparator, _p_p_SoSeparatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSeparatorKit, _p_p_SoSeparatorKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderObject, _p_p_SoShaderObjectTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter, _p_p_SoShaderParameterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter1f, _p_p_SoShaderParameter1fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter1i, _p_p_SoShaderParameter1iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter2f, _p_p_SoShaderParameter2fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter2i, _p_p_SoShaderParameter2iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter3f, _p_p_SoShaderParameter3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter3i, _p_p_SoShaderParameter3iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter4f, _p_p_SoShaderParameter4fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameter4i, _p_p_SoShaderParameter4iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray1f, _p_p_SoShaderParameterArray1fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray1i, _p_p_SoShaderParameterArray1iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray2f, _p_p_SoShaderParameterArray2fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray2i, _p_p_SoShaderParameterArray2iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray3f, _p_p_SoShaderParameterArray3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray3i, _p_p_SoShaderParameterArray3iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray4f, _p_p_SoShaderParameterArray4fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterArray4i, _p_p_SoShaderParameterArray4iTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterMatrix, _p_p_SoShaderParameterMatrixTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderParameterMatrixArray, _p_p_SoShaderParameterMatrixArrayTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderProgram, _p_p_SoShaderProgramTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShaderStateMatrixParameter, _p_p_SoShaderStateMatrixParameterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShape, _p_p_SoShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShapeHints, _p_p_SoShapeHintsTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShapeKit, _p_p_SoShapeKitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoShuttle, _p_p_SoShuttleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSphere, _p_p_SoSphereTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSpotLight, _p_p_SoSpotLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSpotLightDragger, _p_p_SoSpotLightDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSpotLightManip, _p_p_SoSpotLightManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSurroundScale, _p_p_SoSurroundScaleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoSwitch, _p_p_SoSwitchTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTabBoxDragger, _p_p_SoTabBoxDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTabBoxManip, _p_p_SoTabBoxManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTabPlaneDragger, _p_p_SoTabPlaneDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTempPath, _p_p_SoTempPathTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoText2, _p_p_SoText2To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoText3, _p_p_SoText3To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture, _p_p_SoTextureTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture2, _p_p_SoTexture2To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture2Convert, _p_p_SoTexture2ConvertTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture2Transform, _p_p_SoTexture2TransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture3, _p_p_SoTexture3To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTexture3Transform, _p_p_SoTexture3TransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCombine, _p_p_SoTextureCombineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinate2, _p_p_SoTextureCoordinate2To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinate3, _p_p_SoTextureCoordinate3To_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateBinding, _p_p_SoTextureCoordinateBindingTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateCube, _p_p_SoTextureCoordinateCubeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateCylinder, _p_p_SoTextureCoordinateCylinderTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateDefault, _p_p_SoTextureCoordinateDefaultTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateEnvironment, _p_p_SoTextureCoordinateEnvironmentTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateFunction, _p_p_SoTextureCoordinateFunctionTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateNormalMap, _p_p_SoTextureCoordinateNormalMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateObject, _p_p_SoTextureCoordinateObjectTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinatePlane, _p_p_SoTextureCoordinatePlaneTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateReflectionMap, _p_p_SoTextureCoordinateReflectionMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCoordinateSphere, _p_p_SoTextureCoordinateSphereTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureCubeMap, _p_p_SoTextureCubeMapTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureMatrixTransform, _p_p_SoTextureMatrixTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureScalePolicy, _p_p_SoTextureScalePolicyTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTextureUnit, _p_p_SoTextureUnitTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTimeCounter, _p_p_SoTimeCounterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTrackballDragger, _p_p_SoTrackballDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTrackballManip, _p_p_SoTrackballManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransform, _p_p_SoTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformBoxDragger, _p_p_SoTransformBoxDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformBoxManip, _p_p_SoTransformBoxManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformManip, _p_p_SoTransformManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformSeparator, _p_p_SoTransformSeparatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformVec3f, _p_p_SoTransformVec3fTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformation, _p_p_SoTransformationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformerDragger, _p_p_SoTransformerDraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransformerManip, _p_p_SoTransformerManipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTranslate1Dragger, _p_p_SoTranslate1DraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTranslate2Dragger, _p_p_SoTranslate2DraggerTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTranslation, _p_p_SoTranslationTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTransparencyType, _p_p_SoTransparencyTypeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTriangleStripSet, _p_p_SoTriangleStripSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoTriggerAny, _p_p_SoTriggerAnyTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoUniformShaderParameter, _p_p_SoUniformShaderParameterTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoUnits, _p_p_SoUnitsTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLAnchor, _p_p_SoVRMLAnchorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLAppearance, _p_p_SoVRMLAppearanceTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLAudioClip, _p_p_SoVRMLAudioClipTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLBackground, _p_p_SoVRMLBackgroundTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLBillboard, _p_p_SoVRMLBillboardTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLBox, _p_p_SoVRMLBoxTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCollision, _p_p_SoVRMLCollisionTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLColor, _p_p_SoVRMLColorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLColorInterpolator, _p_p_SoVRMLColorInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCone, _p_p_SoVRMLConeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCoordinate, _p_p_SoVRMLCoordinateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCoordinateInterpolator, _p_p_SoVRMLCoordinateInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCylinder, _p_p_SoVRMLCylinderTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLCylinderSensor, _p_p_SoVRMLCylinderSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLDirectionalLight, _p_p_SoVRMLDirectionalLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLDragSensor, _p_p_SoVRMLDragSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLElevationGrid, _p_p_SoVRMLElevationGridTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLExtrusion, _p_p_SoVRMLExtrusionTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLFog, _p_p_SoVRMLFogTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLFontStyle, _p_p_SoVRMLFontStyleTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLGeometry, _p_p_SoVRMLGeometryTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLGroup, _p_p_SoVRMLGroupTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLImageTexture, _p_p_SoVRMLImageTextureTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLIndexedFaceSet, _p_p_SoVRMLIndexedFaceSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLIndexedLine, _p_p_SoVRMLIndexedLineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLIndexedLineSet, _p_p_SoVRMLIndexedLineSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLIndexedShape, _p_p_SoVRMLIndexedShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLInline, _p_p_SoVRMLInlineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLInterpolator, _p_p_SoVRMLInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLLOD, _p_p_SoVRMLLODTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLLight, _p_p_SoVRMLLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLMaterial, _p_p_SoVRMLMaterialTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLMovieTexture, _p_p_SoVRMLMovieTextureTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLNavigationInfo, _p_p_SoVRMLNavigationInfoTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLNormal, _p_p_SoVRMLNormalTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLNormalInterpolator, _p_p_SoVRMLNormalInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLOrientationInterpolator, _p_p_SoVRMLOrientationInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLParent, _p_p_SoVRMLParentTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLPixelTexture, _p_p_SoVRMLPixelTextureTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLPlaneSensor, _p_p_SoVRMLPlaneSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLPointLight, _p_p_SoVRMLPointLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLPointSet, _p_p_SoVRMLPointSetTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLPositionInterpolator, _p_p_SoVRMLPositionInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLProximitySensor, _p_p_SoVRMLProximitySensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLScalarInterpolator, _p_p_SoVRMLScalarInterpolatorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLScript, _p_p_SoVRMLScriptTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSensor, _p_p_SoVRMLSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLShape, _p_p_SoVRMLShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSound, _p_p_SoVRMLSoundTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSphere, _p_p_SoVRMLSphereTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSphereSensor, _p_p_SoVRMLSphereSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSpotLight, _p_p_SoVRMLSpotLightTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLSwitch, _p_p_SoVRMLSwitchTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLText, _p_p_SoVRMLTextTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTexture, _p_p_SoVRMLTextureTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTextureCoordinate, _p_p_SoVRMLTextureCoordinateTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTextureTransform, _p_p_SoVRMLTextureTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTimeSensor, _p_p_SoVRMLTimeSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTouchSensor, _p_p_SoVRMLTouchSensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLTransform, _p_p_SoVRMLTransformTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLVertexLine, _p_p_SoVRMLVertexLineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLVertexPoint, _p_p_SoVRMLVertexPointTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLVertexShape, _p_p_SoVRMLVertexShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLViewpoint, _p_p_SoVRMLViewpointTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLVisibilitySensor, _p_p_SoVRMLVisibilitySensorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVRMLWorldInfo, _p_p_SoVRMLWorldInfoTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVertexAttribute, _p_p_SoVertexAttributeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVertexAttributeBinding, _p_p_SoVertexAttributeBindingTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVertexProperty, _p_p_SoVertexPropertyTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVertexShader, _p_p_SoVertexShaderTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoVertexShape, _p_p_SoVertexShapeTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoWWWAnchor, _p_p_SoWWWAnchorTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoWWWInline, _p_p_SoWWWInlineTo_p_p_SoBase, 0, 0},  {&_swigt__p_p_SoWrapperKit, _p_p_SoWrapperKitTo_p_p_SoBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoEngine[] = {  {&_swigt__p_p_SoEngine, 0, 0, 0},  {&_swigt__p_p_SoBoolOperation, _p_p_SoBoolOperationTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoCalculator, _p_p_SoCalculatorTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeMatrix, _p_p_SoComposeMatrixTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeRotation, _p_p_SoComposeRotationTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeRotationFromTo, _p_p_SoComposeRotationFromToTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeVec2f, _p_p_SoComposeVec2fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeVec3f, _p_p_SoComposeVec3fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComposeVec4f, _p_p_SoComposeVec4fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoComputeBoundingBox, _p_p_SoComputeBoundingBoxTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoConcatenate, _p_p_SoConcatenateTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoCounter, _p_p_SoCounterTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoDecomposeMatrix, _p_p_SoDecomposeMatrixTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoDecomposeRotation, _p_p_SoDecomposeRotationTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoDecomposeVec2f, _p_p_SoDecomposeVec2fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoDecomposeVec3f, _p_p_SoDecomposeVec3fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoDecomposeVec4f, _p_p_SoDecomposeVec4fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoElapsedTime, _p_p_SoElapsedTimeTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoFieldConverter, _p_p_SoFieldConverterTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoGate, _p_p_SoGateTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoHeightMapToNormalMap, _p_p_SoHeightMapToNormalMapTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolate, _p_p_SoInterpolateTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolateFloat, _p_p_SoInterpolateFloatTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolateRotation, _p_p_SoInterpolateRotationTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolateVec2f, _p_p_SoInterpolateVec2fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolateVec3f, _p_p_SoInterpolateVec3fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoInterpolateVec4f, _p_p_SoInterpolateVec4fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoOnOff, _p_p_SoOnOffTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoOneShot, _p_p_SoOneShotTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoSelectOne, _p_p_SoSelectOneTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoTexture2Convert, _p_p_SoTexture2ConvertTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoTimeCounter, _p_p_SoTimeCounterTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoTransformVec3f, _p_p_SoTransformVec3fTo_p_p_SoEngine, 0, 0},  {&_swigt__p_p_SoTriggerAny, _p_p_SoTriggerAnyTo_p_p_SoEngine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoEngineOutput[] = {  {&_swigt__p_p_SoEngineOutput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFBitMask[] = {{&_swigt__p_p_SoMFBitMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFBool[] = {{&_swigt__p_p_SoMFBool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFColor[] = {{&_swigt__p_p_SoMFColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFColorRGBA[] = {{&_swigt__p_p_SoMFColorRGBA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFDouble[] = {{&_swigt__p_p_SoMFDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFEngine[] = {{&_swigt__p_p_SoMFEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFEnum[] = {{&_swigt__p_p_SoMFEnum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFFloat[] = {{&_swigt__p_p_SoMFFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFInt32[] = {{&_swigt__p_p_SoMFInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFMatrix[] = {{&_swigt__p_p_SoMFMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFName[] = {{&_swigt__p_p_SoMFName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFNode[] = {{&_swigt__p_p_SoMFNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFPath[] = {{&_swigt__p_p_SoMFPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFPlane[] = {{&_swigt__p_p_SoMFPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFRotation[] = {{&_swigt__p_p_SoMFRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFShort[] = {{&_swigt__p_p_SoMFShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFString[] = {{&_swigt__p_p_SoMFString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFTime[] = {{&_swigt__p_p_SoMFTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFUInt32[] = {{&_swigt__p_p_SoMFUInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFUShort[] = {{&_swigt__p_p_SoMFUShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec2b[] = {{&_swigt__p_p_SoMFVec2b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec2d[] = {{&_swigt__p_p_SoMFVec2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec2f[] = {{&_swigt__p_p_SoMFVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec2i32[] = {{&_swigt__p_p_SoMFVec2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec2s[] = {{&_swigt__p_p_SoMFVec2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec3b[] = {{&_swigt__p_p_SoMFVec3b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec3d[] = {{&_swigt__p_p_SoMFVec3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec3f[] = {{&_swigt__p_p_SoMFVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec3i32[] = {{&_swigt__p_p_SoMFVec3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec3s[] = {{&_swigt__p_p_SoMFVec3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4b[] = {{&_swigt__p_p_SoMFVec4b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4d[] = {{&_swigt__p_p_SoMFVec4d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4f[] = {{&_swigt__p_p_SoMFVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4i32[] = {{&_swigt__p_p_SoMFVec4i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4s[] = {{&_swigt__p_p_SoMFVec4s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4ub[] = {{&_swigt__p_p_SoMFVec4ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4ui32[] = {{&_swigt__p_p_SoMFVec4ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMFVec4us[] = {{&_swigt__p_p_SoMFVec4us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBitMask[] = {{&_swigt__p_p_SoSFBitMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBool[] = {{&_swigt__p_p_SoSFBool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox2d[] = {{&_swigt__p_p_SoSFBox2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox2f[] = {{&_swigt__p_p_SoSFBox2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox2i32[] = {{&_swigt__p_p_SoSFBox2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox2s[] = {{&_swigt__p_p_SoSFBox2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox3d[] = {{&_swigt__p_p_SoSFBox3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox3f[] = {{&_swigt__p_p_SoSFBox3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox3i32[] = {{&_swigt__p_p_SoSFBox3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFBox3s[] = {{&_swigt__p_p_SoSFBox3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFColor[] = {{&_swigt__p_p_SoSFColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFColorRGBA[] = {{&_swigt__p_p_SoSFColorRGBA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFDouble[] = {{&_swigt__p_p_SoSFDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFEngine[] = {{&_swigt__p_p_SoSFEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFEnum[] = {{&_swigt__p_p_SoSFEnum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFFloat[] = {{&_swigt__p_p_SoSFFloat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFImage[] = {{&_swigt__p_p_SoSFImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFImage3[] = {{&_swigt__p_p_SoSFImage3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFInt32[] = {{&_swigt__p_p_SoSFInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFMatrix[] = {{&_swigt__p_p_SoSFMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFName[] = {{&_swigt__p_p_SoSFName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFNode[] = {{&_swigt__p_p_SoSFNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFPath[] = {{&_swigt__p_p_SoSFPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFPlane[] = {{&_swigt__p_p_SoSFPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFRotation[] = {{&_swigt__p_p_SoSFRotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFShort[] = {{&_swigt__p_p_SoSFShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFString[] = {{&_swigt__p_p_SoSFString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFTime[] = {{&_swigt__p_p_SoSFTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFTrigger[] = {{&_swigt__p_p_SoSFTrigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFUInt32[] = {{&_swigt__p_p_SoSFUInt32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFUShort[] = {{&_swigt__p_p_SoSFUShort, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec2b[] = {{&_swigt__p_p_SoSFVec2b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec2d[] = {{&_swigt__p_p_SoSFVec2d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec2f[] = {{&_swigt__p_p_SoSFVec2f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec2i32[] = {{&_swigt__p_p_SoSFVec2i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec2s[] = {{&_swigt__p_p_SoSFVec2s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec3b[] = {{&_swigt__p_p_SoSFVec3b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec3d[] = {{&_swigt__p_p_SoSFVec3d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec3f[] = {{&_swigt__p_p_SoSFVec3f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec3i32[] = {{&_swigt__p_p_SoSFVec3i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec3s[] = {{&_swigt__p_p_SoSFVec3s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4b[] = {{&_swigt__p_p_SoSFVec4b, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4d[] = {{&_swigt__p_p_SoSFVec4d, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4f[] = {{&_swigt__p_p_SoSFVec4f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4i32[] = {{&_swigt__p_p_SoSFVec4i32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4s[] = {{&_swigt__p_p_SoSFVec4s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4ub[] = {{&_swigt__p_p_SoSFVec4ub, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4ui32[] = {{&_swigt__p_p_SoSFVec4ui32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSFVec4us[] = {{&_swigt__p_p_SoSFVec4us, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoSField[] = {{&_swigt__p_p_SoSField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoField[] = {  {&_swigt__p_p_SoField, 0, 0, 0},  {&_swigt__p_p_SoMFBitMask, _p_p_SoMFBitMaskTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFBool, _p_p_SoMFBoolTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFColor, _p_p_SoMFColorTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFColorRGBA, _p_p_SoMFColorRGBATo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFDouble, _p_p_SoMFDoubleTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFEngine, _p_p_SoMFEngineTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFEnum, _p_p_SoMFEnumTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFFloat, _p_p_SoMFFloatTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFInt32, _p_p_SoMFInt32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFMatrix, _p_p_SoMFMatrixTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFName, _p_p_SoMFNameTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFNode, _p_p_SoMFNodeTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFPath, _p_p_SoMFPathTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFPlane, _p_p_SoMFPlaneTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFRotation, _p_p_SoMFRotationTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFShort, _p_p_SoMFShortTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFString, _p_p_SoMFStringTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFTime, _p_p_SoMFTimeTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFUInt32, _p_p_SoMFUInt32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFUShort, _p_p_SoMFUShortTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec2b, _p_p_SoMFVec2bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec2d, _p_p_SoMFVec2dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec2f, _p_p_SoMFVec2fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec2i32, _p_p_SoMFVec2i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec2s, _p_p_SoMFVec2sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec3b, _p_p_SoMFVec3bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec3d, _p_p_SoMFVec3dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec3f, _p_p_SoMFVec3fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec3i32, _p_p_SoMFVec3i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec3s, _p_p_SoMFVec3sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4b, _p_p_SoMFVec4bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4d, _p_p_SoMFVec4dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4f, _p_p_SoMFVec4fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4i32, _p_p_SoMFVec4i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4s, _p_p_SoMFVec4sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4ub, _p_p_SoMFVec4ubTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4ui32, _p_p_SoMFVec4ui32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMFVec4us, _p_p_SoMFVec4usTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoMField, _p_p_SoMFieldTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBitMask, _p_p_SoSFBitMaskTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBool, _p_p_SoSFBoolTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox2d, _p_p_SoSFBox2dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox2f, _p_p_SoSFBox2fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox2i32, _p_p_SoSFBox2i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox2s, _p_p_SoSFBox2sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox3d, _p_p_SoSFBox3dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox3f, _p_p_SoSFBox3fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox3i32, _p_p_SoSFBox3i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFBox3s, _p_p_SoSFBox3sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFColor, _p_p_SoSFColorTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFColorRGBA, _p_p_SoSFColorRGBATo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFDouble, _p_p_SoSFDoubleTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFEngine, _p_p_SoSFEngineTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFEnum, _p_p_SoSFEnumTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFFloat, _p_p_SoSFFloatTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFImage, _p_p_SoSFImageTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFImage3, _p_p_SoSFImage3To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFInt32, _p_p_SoSFInt32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFMatrix, _p_p_SoSFMatrixTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFName, _p_p_SoSFNameTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFNode, _p_p_SoSFNodeTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFPath, _p_p_SoSFPathTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFPlane, _p_p_SoSFPlaneTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFRotation, _p_p_SoSFRotationTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFShort, _p_p_SoSFShortTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFString, _p_p_SoSFStringTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFTime, _p_p_SoSFTimeTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFTrigger, _p_p_SoSFTriggerTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFUInt32, _p_p_SoSFUInt32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFUShort, _p_p_SoSFUShortTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec2b, _p_p_SoSFVec2bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec2d, _p_p_SoSFVec2dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec2f, _p_p_SoSFVec2fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec2i32, _p_p_SoSFVec2i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec2s, _p_p_SoSFVec2sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec3b, _p_p_SoSFVec3bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec3d, _p_p_SoSFVec3dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec3f, _p_p_SoSFVec3fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec3i32, _p_p_SoSFVec3i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec3s, _p_p_SoSFVec3sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4b, _p_p_SoSFVec4bTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4d, _p_p_SoSFVec4dTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4f, _p_p_SoSFVec4fTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4i32, _p_p_SoSFVec4i32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4s, _p_p_SoSFVec4sTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4ub, _p_p_SoSFVec4ubTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4ui32, _p_p_SoSFVec4ui32To_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSFVec4us, _p_p_SoSFVec4usTo_p_p_SoField, 0, 0},  {&_swigt__p_p_SoSField, _p_p_SoSFieldTo_p_p_SoField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoBoxHighlightRenderAction[] = {{&_swigt__p_p_SoBoxHighlightRenderAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoLineHighlightRenderAction[] = {{&_swigt__p_p_SoLineHighlightRenderAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoGLRenderAction[] = {  {&_swigt__p_p_SoGLRenderAction, 0, 0, 0},  {&_swigt__p_p_SoBoxHighlightRenderAction, _p_p_SoBoxHighlightRenderActionTo_p_p_SoGLRenderAction, 0, 0},  {&_swigt__p_p_SoLineHighlightRenderAction, _p_p_SoLineHighlightRenderActionTo_p_p_SoGLRenderAction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoMField[] = {  {&_swigt__p_p_SoMField, 0, 0, 0},  {&_swigt__p_p_SoMFBitMask, _p_p_SoMFBitMaskTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFBool, _p_p_SoMFBoolTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFColor, _p_p_SoMFColorTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFColorRGBA, _p_p_SoMFColorRGBATo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFDouble, _p_p_SoMFDoubleTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFEngine, _p_p_SoMFEngineTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFEnum, _p_p_SoMFEnumTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFFloat, _p_p_SoMFFloatTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFInt32, _p_p_SoMFInt32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFMatrix, _p_p_SoMFMatrixTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFName, _p_p_SoMFNameTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFNode, _p_p_SoMFNodeTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFPath, _p_p_SoMFPathTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFPlane, _p_p_SoMFPlaneTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFRotation, _p_p_SoMFRotationTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFShort, _p_p_SoMFShortTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFString, _p_p_SoMFStringTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFTime, _p_p_SoMFTimeTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFUInt32, _p_p_SoMFUInt32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFUShort, _p_p_SoMFUShortTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec2b, _p_p_SoMFVec2bTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec2d, _p_p_SoMFVec2dTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec2f, _p_p_SoMFVec2fTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec2i32, _p_p_SoMFVec2i32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec2s, _p_p_SoMFVec2sTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec3b, _p_p_SoMFVec3bTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec3d, _p_p_SoMFVec3dTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec3f, _p_p_SoMFVec3fTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec3i32, _p_p_SoMFVec3i32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec3s, _p_p_SoMFVec3sTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4b, _p_p_SoMFVec4bTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4d, _p_p_SoMFVec4dTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4f, _p_p_SoMFVec4fTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4i32, _p_p_SoMFVec4i32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4s, _p_p_SoMFVec4sTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4ub, _p_p_SoMFVec4ubTo_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4ui32, _p_p_SoMFVec4ui32To_p_p_SoMField, 0, 0},  {&_swigt__p_p_SoMFVec4us, _p_p_SoMFVec4usTo_p_p_SoMField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoNode[] = {  {&_swigt__p_p_SoNode, 0, 0, 0},  {&_swigt__p_p_SoAlphaTest, _p_p_SoAlphaTestTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoAnnotation, _p_p_SoAnnotationTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoAntiSquish, _p_p_SoAntiSquishTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoAppearanceKit, _p_p_SoAppearanceKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoArray, _p_p_SoArrayTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoAsciiText, _p_p_SoAsciiTextTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBaseColor, _p_p_SoBaseColorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBaseKit, _p_p_SoBaseKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBlinker, _p_p_SoBlinkerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBumpMap, _p_p_SoBumpMapTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBumpMapCoordinate, _p_p_SoBumpMapCoordinateTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoBumpMapTransform, _p_p_SoBumpMapTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCacheHint, _p_p_SoCacheHintTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCallback, _p_p_SoCallbackTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCamera, _p_p_SoCameraTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCameraKit, _p_p_SoCameraKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCenterballDragger, _p_p_SoCenterballDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCenterballManip, _p_p_SoCenterballManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoClipPlane, _p_p_SoClipPlaneTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoClipPlaneManip, _p_p_SoClipPlaneManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoColorIndex, _p_p_SoColorIndexTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoComplexity, _p_p_SoComplexityTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCone, _p_p_SoConeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCoordinate3, _p_p_SoCoordinate3To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCoordinate4, _p_p_SoCoordinate4To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCube, _p_p_SoCubeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoCylinder, _p_p_SoCylinderTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDepthBuffer, _p_p_SoDepthBufferTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDirectionalLight, _p_p_SoDirectionalLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDirectionalLightDragger, _p_p_SoDirectionalLightDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDirectionalLightManip, _p_p_SoDirectionalLightManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDragPointDragger, _p_p_SoDragPointDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDragger, _p_p_SoDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoDrawStyle, _p_p_SoDrawStyleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoEnvironment, _p_p_SoEnvironmentTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoEventCallback, _p_p_SoEventCallbackTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoExtSelection, _p_p_SoExtSelectionTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFaceSet, _p_p_SoFaceSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFile, _p_p_SoFileTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFont, _p_p_SoFontTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFontStyle, _p_p_SoFontStyleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFragmentShader, _p_p_SoFragmentShaderTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoFrustumCamera, _p_p_SoFrustumCameraTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoGeoCoordinate, _p_p_SoGeoCoordinateTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoGeoLocation, _p_p_SoGeoLocationTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoGeoOrigin, _p_p_SoGeoOriginTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoGeoSeparator, _p_p_SoGeoSeparatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoGroup, _p_p_SoGroupTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoHandleBoxDragger, _p_p_SoHandleBoxDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoHandleBoxManip, _p_p_SoHandleBoxManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoImage, _p_p_SoImageTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedFaceSet, _p_p_SoIndexedFaceSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedLineSet, _p_p_SoIndexedLineSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedMarkerSet, _p_p_SoIndexedMarkerSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedNurbsCurve, _p_p_SoIndexedNurbsCurveTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedNurbsSurface, _p_p_SoIndexedNurbsSurfaceTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedPointSet, _p_p_SoIndexedPointSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedShape, _p_p_SoIndexedShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoIndexedTriangleStripSet, _p_p_SoIndexedTriangleStripSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoInfo, _p_p_SoInfoTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoInteractionKit, _p_p_SoInteractionKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoJackDragger, _p_p_SoJackDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoJackManip, _p_p_SoJackManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLOD, _p_p_SoLODTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLabel, _p_p_SoLabelTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLevelOfDetail, _p_p_SoLevelOfDetailTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLight, _p_p_SoLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLightKit, _p_p_SoLightKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLightModel, _p_p_SoLightModelTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLineSet, _p_p_SoLineSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLinearProfile, _p_p_SoLinearProfileTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoListener, _p_p_SoListenerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoLocateHighlight, _p_p_SoLocateHighlightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoMarkerSet, _p_p_SoMarkerSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoMaterial, _p_p_SoMaterialTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoMaterialBinding, _p_p_SoMaterialBindingTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoMatrixTransform, _p_p_SoMatrixTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoMultipleCopy, _p_p_SoMultipleCopyTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNodeEngine, _p_p_SoNodeEngineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNodeKitListPart, _p_p_SoNodeKitListPartTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNonIndexedShape, _p_p_SoNonIndexedShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNormal, _p_p_SoNormalTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNormalBinding, _p_p_SoNormalBindingTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNurbsCurve, _p_p_SoNurbsCurveTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNurbsProfile, _p_p_SoNurbsProfileTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoNurbsSurface, _p_p_SoNurbsSurfaceTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoOrthographicCamera, _p_p_SoOrthographicCameraTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPackedColor, _p_p_SoPackedColorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPathSwitch, _p_p_SoPathSwitchTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPendulum, _p_p_SoPendulumTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPerspectiveCamera, _p_p_SoPerspectiveCameraTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPickStyle, _p_p_SoPickStyleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPointLight, _p_p_SoPointLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPointLightDragger, _p_p_SoPointLightDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPointLightManip, _p_p_SoPointLightManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPointSet, _p_p_SoPointSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoPolygonOffset, _p_p_SoPolygonOffsetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoProfile, _p_p_SoProfileTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoProfileCoordinate2, _p_p_SoProfileCoordinate2To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoProfileCoordinate3, _p_p_SoProfileCoordinate3To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoProto, _p_p_SoProtoTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoProtoInstance, _p_p_SoProtoInstanceTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoQuadMesh, _p_p_SoQuadMeshTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoResetTransform, _p_p_SoResetTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoReversePerspectiveCamera, _p_p_SoReversePerspectiveCameraTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotateCylindricalDragger, _p_p_SoRotateCylindricalDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotateDiscDragger, _p_p_SoRotateDiscDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotateSphericalDragger, _p_p_SoRotateSphericalDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotation, _p_p_SoRotationTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotationXYZ, _p_p_SoRotationXYZTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoRotor, _p_p_SoRotorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoScale, _p_p_SoScaleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoScale1Dragger, _p_p_SoScale1DraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoScale2Dragger, _p_p_SoScale2DraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoScale2UniformDragger, _p_p_SoScale2UniformDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoScaleUniformDragger, _p_p_SoScaleUniformDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSceneKit, _p_p_SoSceneKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSceneTexture2, _p_p_SoSceneTexture2To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSceneTextureCubeMap, _p_p_SoSceneTextureCubeMapTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSelection, _p_p_SoSelectionTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSeparator, _p_p_SoSeparatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSeparatorKit, _p_p_SoSeparatorKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderObject, _p_p_SoShaderObjectTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter, _p_p_SoShaderParameterTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter1f, _p_p_SoShaderParameter1fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter1i, _p_p_SoShaderParameter1iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter2f, _p_p_SoShaderParameter2fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter2i, _p_p_SoShaderParameter2iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter3f, _p_p_SoShaderParameter3fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter3i, _p_p_SoShaderParameter3iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter4f, _p_p_SoShaderParameter4fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameter4i, _p_p_SoShaderParameter4iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray1f, _p_p_SoShaderParameterArray1fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray1i, _p_p_SoShaderParameterArray1iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray2f, _p_p_SoShaderParameterArray2fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray2i, _p_p_SoShaderParameterArray2iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray3f, _p_p_SoShaderParameterArray3fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray3i, _p_p_SoShaderParameterArray3iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray4f, _p_p_SoShaderParameterArray4fTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterArray4i, _p_p_SoShaderParameterArray4iTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterMatrix, _p_p_SoShaderParameterMatrixTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderParameterMatrixArray, _p_p_SoShaderParameterMatrixArrayTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderProgram, _p_p_SoShaderProgramTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShaderStateMatrixParameter, _p_p_SoShaderStateMatrixParameterTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShape, _p_p_SoShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShapeHints, _p_p_SoShapeHintsTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShapeKit, _p_p_SoShapeKitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoShuttle, _p_p_SoShuttleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSphere, _p_p_SoSphereTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSpotLight, _p_p_SoSpotLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSpotLightDragger, _p_p_SoSpotLightDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSpotLightManip, _p_p_SoSpotLightManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSurroundScale, _p_p_SoSurroundScaleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoSwitch, _p_p_SoSwitchTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTabBoxDragger, _p_p_SoTabBoxDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTabBoxManip, _p_p_SoTabBoxManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTabPlaneDragger, _p_p_SoTabPlaneDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoText2, _p_p_SoText2To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoText3, _p_p_SoText3To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTexture, _p_p_SoTextureTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTexture2, _p_p_SoTexture2To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTexture2Transform, _p_p_SoTexture2TransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTexture3, _p_p_SoTexture3To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTexture3Transform, _p_p_SoTexture3TransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCombine, _p_p_SoTextureCombineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinate2, _p_p_SoTextureCoordinate2To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinate3, _p_p_SoTextureCoordinate3To_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateBinding, _p_p_SoTextureCoordinateBindingTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateCube, _p_p_SoTextureCoordinateCubeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateCylinder, _p_p_SoTextureCoordinateCylinderTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateDefault, _p_p_SoTextureCoordinateDefaultTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateEnvironment, _p_p_SoTextureCoordinateEnvironmentTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateFunction, _p_p_SoTextureCoordinateFunctionTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateNormalMap, _p_p_SoTextureCoordinateNormalMapTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateObject, _p_p_SoTextureCoordinateObjectTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinatePlane, _p_p_SoTextureCoordinatePlaneTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateReflectionMap, _p_p_SoTextureCoordinateReflectionMapTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCoordinateSphere, _p_p_SoTextureCoordinateSphereTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureCubeMap, _p_p_SoTextureCubeMapTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureMatrixTransform, _p_p_SoTextureMatrixTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureScalePolicy, _p_p_SoTextureScalePolicyTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTextureUnit, _p_p_SoTextureUnitTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTrackballDragger, _p_p_SoTrackballDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTrackballManip, _p_p_SoTrackballManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransform, _p_p_SoTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformBoxDragger, _p_p_SoTransformBoxDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformBoxManip, _p_p_SoTransformBoxManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformManip, _p_p_SoTransformManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformSeparator, _p_p_SoTransformSeparatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformation, _p_p_SoTransformationTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformerDragger, _p_p_SoTransformerDraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransformerManip, _p_p_SoTransformerManipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTranslate1Dragger, _p_p_SoTranslate1DraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTranslate2Dragger, _p_p_SoTranslate2DraggerTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTranslation, _p_p_SoTranslationTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTransparencyType, _p_p_SoTransparencyTypeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoTriangleStripSet, _p_p_SoTriangleStripSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoUniformShaderParameter, _p_p_SoUniformShaderParameterTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoUnits, _p_p_SoUnitsTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLAnchor, _p_p_SoVRMLAnchorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLAppearance, _p_p_SoVRMLAppearanceTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLAudioClip, _p_p_SoVRMLAudioClipTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLBackground, _p_p_SoVRMLBackgroundTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLBillboard, _p_p_SoVRMLBillboardTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLBox, _p_p_SoVRMLBoxTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCollision, _p_p_SoVRMLCollisionTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLColor, _p_p_SoVRMLColorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLColorInterpolator, _p_p_SoVRMLColorInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCone, _p_p_SoVRMLConeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCoordinate, _p_p_SoVRMLCoordinateTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCoordinateInterpolator, _p_p_SoVRMLCoordinateInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCylinder, _p_p_SoVRMLCylinderTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLCylinderSensor, _p_p_SoVRMLCylinderSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLDirectionalLight, _p_p_SoVRMLDirectionalLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLDragSensor, _p_p_SoVRMLDragSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLElevationGrid, _p_p_SoVRMLElevationGridTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLExtrusion, _p_p_SoVRMLExtrusionTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLFog, _p_p_SoVRMLFogTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLFontStyle, _p_p_SoVRMLFontStyleTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLGeometry, _p_p_SoVRMLGeometryTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLGroup, _p_p_SoVRMLGroupTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLImageTexture, _p_p_SoVRMLImageTextureTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLIndexedFaceSet, _p_p_SoVRMLIndexedFaceSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLIndexedLine, _p_p_SoVRMLIndexedLineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLIndexedLineSet, _p_p_SoVRMLIndexedLineSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLIndexedShape, _p_p_SoVRMLIndexedShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLInline, _p_p_SoVRMLInlineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLInterpolator, _p_p_SoVRMLInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLLOD, _p_p_SoVRMLLODTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLLight, _p_p_SoVRMLLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLMaterial, _p_p_SoVRMLMaterialTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLMovieTexture, _p_p_SoVRMLMovieTextureTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLNavigationInfo, _p_p_SoVRMLNavigationInfoTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLNormal, _p_p_SoVRMLNormalTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLNormalInterpolator, _p_p_SoVRMLNormalInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLOrientationInterpolator, _p_p_SoVRMLOrientationInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLParent, _p_p_SoVRMLParentTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLPixelTexture, _p_p_SoVRMLPixelTextureTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLPlaneSensor, _p_p_SoVRMLPlaneSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLPointLight, _p_p_SoVRMLPointLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLPointSet, _p_p_SoVRMLPointSetTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLPositionInterpolator, _p_p_SoVRMLPositionInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLProximitySensor, _p_p_SoVRMLProximitySensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLScalarInterpolator, _p_p_SoVRMLScalarInterpolatorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLScript, _p_p_SoVRMLScriptTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSensor, _p_p_SoVRMLSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLShape, _p_p_SoVRMLShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSound, _p_p_SoVRMLSoundTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSphere, _p_p_SoVRMLSphereTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSphereSensor, _p_p_SoVRMLSphereSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSpotLight, _p_p_SoVRMLSpotLightTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLSwitch, _p_p_SoVRMLSwitchTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLText, _p_p_SoVRMLTextTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTexture, _p_p_SoVRMLTextureTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTextureCoordinate, _p_p_SoVRMLTextureCoordinateTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTextureTransform, _p_p_SoVRMLTextureTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTimeSensor, _p_p_SoVRMLTimeSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTouchSensor, _p_p_SoVRMLTouchSensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLTransform, _p_p_SoVRMLTransformTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLVertexLine, _p_p_SoVRMLVertexLineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLVertexPoint, _p_p_SoVRMLVertexPointTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLVertexShape, _p_p_SoVRMLVertexShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLViewpoint, _p_p_SoVRMLViewpointTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLVisibilitySensor, _p_p_SoVRMLVisibilitySensorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVRMLWorldInfo, _p_p_SoVRMLWorldInfoTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVertexAttribute, _p_p_SoVertexAttributeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVertexAttributeBinding, _p_p_SoVertexAttributeBindingTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVertexProperty, _p_p_SoVertexPropertyTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVertexShader, _p_p_SoVertexShaderTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoVertexShape, _p_p_SoVertexShapeTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoWWWAnchor, _p_p_SoWWWAnchorTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoWWWInline, _p_p_SoWWWInlineTo_p_p_SoNode, 0, 0},  {&_swigt__p_p_SoWrapperKit, _p_p_SoWrapperKitTo_p_p_SoNode, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SoPath[] = {  {&_swigt__p_p_SoPath, 0, 0, 0},  {&_swigt__p_p_SoFullPath, _p_p_SoFullPathTo_p_p_SoPath, 0, 0},  {&_swigt__p_p_SoNodeKitPath, _p_p_SoNodeKitPathTo_p_p_SoPath, 0, 0},  {&_swigt__p_p_SoTempPath, _p_p_SoTempPathTo_p_p_SoPath, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_charp[] = {{&_swigt__p_p_charp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},  {&_swigt__p_p_charp, _p_p_charpTo_p_p_char, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_SoAction_p_SoNode__void[] = {  {&_swigt__p_p_f_p_SoAction_p_SoNode__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void__SoGLRenderAction__AbortCode[] = {  {&_swigt__p_p_f_p_void__SoGLRenderAction__AbortCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_SoInput__void[] = {  {&_swigt__p_p_f_p_void_p_SoInput__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_floatp[] = {{&_swigt__p_p_floatp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_float[] = {  {&_swigt__p_p_float, 0, 0, 0},  {&_swigt__p_p_floatp, _p_p_floatpTo_p_p_float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_intp[] = {{&_swigt__p_p_intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_int[] = {  {&_swigt__p_p_int, 0, 0, 0},  {&_swigt__p_p_intp, _p_p_intpTo_p_p_int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_char[] = {  {&_swigt__p_p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_read_func[] = {  {&_swigt__p_read_func, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_seek_func[] = {  {&_swigt__p_seek_func, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__FILE[] = {  {&_swigt__p_std__FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_tell_func[] = {  {&_swigt__p_tell_func, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_time_t[] = {  {&_swigt__p_time_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_timeval[] = {  {&_swigt__p_timeval, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_wchar_t[] = {  {&_swigt__p_wchar_t, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_AttributeApplyFunc,
  _swigc__p_ContextDestructionCB,
  _swigc__p_FILE,
  _swigc__p_Key,
  _swigc__p_ProgressCallbackType,
  _swigc__p_SbBSPTree,
  _swigc__p_SbBarrier,
  _swigc__p_SbBox2d,
  _swigc__p_SbBox2f,
  _swigc__p_SbBox2i32,
  _swigc__p_SbBox2s,
  _swigc__p_SbBox3d,
  _swigc__p_SbBox3f,
  _swigc__p_SbBox3i32,
  _swigc__p_SbBox3s,
  _swigc__p_SbByteBuffer,
  _swigc__p_SbClip,
  _swigc__p_SbColor,
  _swigc__p_SbColor4f,
  _swigc__p_SbCondVar,
  _swigc__p_SbCylinder,
  _swigc__p_SbCylinderPlaneProjector,
  _swigc__p_SbCylinderProjector,
  _swigc__p_SbCylinderSectionProjector,
  _swigc__p_SbCylinderSheetProjector,
  _swigc__p_SbDPLine,
  _swigc__p_SbDPMatrix,
  _swigc__p_SbDPPlane,
  _swigc__p_SbDPRotation,
  _swigc__p_SbDPViewVolume,
  _swigc__p_SbDict,
  _swigc__p_SbFifo,
  _swigc__p_SbHeap,
  _swigc__p_SbHeapFuncs,
  _swigc__p_SbImage,
  _swigc__p_SbIntList,
  _swigc__p_SbLine,
  _swigc__p_SbLineProjector,
  _swigc__p_SbListT_SbString_t,
  _swigc__p_SbListT_char_const_p_t,
  _swigc__p_SbListT_int_t,
  _swigc__p_SbListT_void_p_t,
  _swigc__p_SbMatrix,
  _swigc__p_SbMutex,
  _swigc__p_SbName,
  _swigc__p_SbOctTree,
  _swigc__p_SbOctTreeFuncs,
  _swigc__p_SbPList,
  _swigc__p_SbPlane,
  _swigc__p_SbPlaneProjector,
  _swigc__p_SbProjector,
  _swigc__p_SbRWMutex,
  _swigc__p_SbRotation,
  _swigc__p_SbSphere,
  _swigc__p_SbSpherePlaneProjector,
  _swigc__p_SbSphereProjector,
  _swigc__p_SbSphereSectionProjector,
  _swigc__p_SbSphereSheetProjector,
  _swigc__p_SbStorage,
  _swigc__p_SbString,
  _swigc__p_SbStringList,
  _swigc__p_SbTesselator,
  _swigc__p_SbThread,
  _swigc__p_SbThreadAutoLock,
  _swigc__p_SbThreadMutex,
  _swigc__p_SbTime,
  _swigc__p_SbVec2b,
  _swigc__p_SbVec2d,
  _swigc__p_SbVec2f,
  _swigc__p_SbVec2i32,
  _swigc__p_SbVec2s,
  _swigc__p_SbVec2ub,
  _swigc__p_SbVec2ui32,
  _swigc__p_SbVec2us,
  _swigc__p_SbVec3b,
  _swigc__p_SbVec3d,
  _swigc__p_SbVec3f,
  _swigc__p_SbVec3fList,
  _swigc__p_SbVec3i32,
  _swigc__p_SbVec3s,
  _swigc__p_SbVec3ub,
  _swigc__p_SbVec3ui32,
  _swigc__p_SbVec3us,
  _swigc__p_SbVec4b,
  _swigc__p_SbVec4d,
  _swigc__p_SbVec4f,
  _swigc__p_SbVec4i32,
  _swigc__p_SbVec4s,
  _swigc__p_SbVec4ub,
  _swigc__p_SbVec4ui32,
  _swigc__p_SbVec4us,
  _swigc__p_SbViewVolume,
  _swigc__p_SbViewportRegion,
  _swigc__p_SbXfBox3f,
  _swigc__p_ScXML,
  _swigc__p_ScXMLAbstractStateElt,
  _swigc__p_ScXMLAddOpExprDataObj,
  _swigc__p_ScXMLAnchorElt,
  _swigc__p_ScXMLAndOpExprDataObj,
  _swigc__p_ScXMLAppendOpExprDataObj,
  _swigc__p_ScXMLAssignElt,
  _swigc__p_ScXMLBoolDataObj,
  _swigc__p_ScXMLCoinAddOpExprDataObj,
  _swigc__p_ScXMLCoinDivideOpExprDataObj,
  _swigc__p_ScXMLCoinEqualsOpExprDataObj,
  _swigc__p_ScXMLCoinEvaluator,
  _swigc__p_ScXMLCoinLengthFuncExprDataObj,
  _swigc__p_ScXMLCoinMultiplyOpExprDataObj,
  _swigc__p_ScXMLCoinSubtractOpExprDataObj,
  _swigc__p_ScXMLConstantDataObj,
  _swigc__p_ScXMLContentElt,
  _swigc__p_ScXMLDataElt,
  _swigc__p_ScXMLDataModelElt,
  _swigc__p_ScXMLDataObj,
  _swigc__p_ScXMLDivideOpExprDataObj,
  _swigc__p_ScXMLDocument,
  _swigc__p_ScXMLECMAScriptEvaluator,
  _swigc__p_ScXMLElseElt,
  _swigc__p_ScXMLElseIfElt,
  _swigc__p_ScXMLElt,
  _swigc__p_ScXMLEltReader,
  _swigc__p_ScXMLEqualsOpExprDataObj,
  _swigc__p_ScXMLEvaluator,
  _swigc__p_ScXMLEvent,
  _swigc__p_ScXMLEventElt,
  _swigc__p_ScXMLEventTarget,
  _swigc__p_ScXMLExecutableElt,
  _swigc__p_ScXMLExprDataObj,
  _swigc__p_ScXMLFinalElt,
  _swigc__p_ScXMLFinalizeElt,
  _swigc__p_ScXMLHistoryElt,
  _swigc__p_ScXMLIfElt,
  _swigc__p_ScXMLInExprDataObj,
  _swigc__p_ScXMLInitialElt,
  _swigc__p_ScXMLInvokeElt,
  _swigc__p_ScXMLLogElt,
  _swigc__p_ScXMLMinimumEvaluator,
  _swigc__p_ScXMLMinimumExprDataObj,
  _swigc__p_ScXMLMultiplyOpExprDataObj,
  _swigc__p_ScXMLNegateOpExprDataObj,
  _swigc__p_ScXMLNotOpExprDataObj,
  _swigc__p_ScXMLObject,
  _swigc__p_ScXMLOnEntryElt,
  _swigc__p_ScXMLOnExitElt,
  _swigc__p_ScXMLOrOpExprDataObj,
  _swigc__p_ScXMLParallelElt,
  _swigc__p_ScXMLParamElt,
  _swigc__p_ScXMLRealDataObj,
  _swigc__p_ScXMLReferenceDataObj,
  _swigc__p_ScXMLSbDataObj,
  _swigc__p_ScXMLScriptElt,
  _swigc__p_ScXMLScxmlElt,
  _swigc__p_ScXMLSendElt,
  _swigc__p_ScXMLStateElt,
  _swigc__p_ScXMLStateMachine,
  _swigc__p_ScXMLStringDataObj,
  _swigc__p_ScXMLSubtractOpExprDataObj,
  _swigc__p_ScXMLTransitionElt,
  _swigc__p_ScXMLValidateElt,
  _swigc__p_ScXMLXMLDataObj,
  _swigc__p_ScXMLXPathEvaluator,
  _swigc__p_SoAccumulatedElement,
  _swigc__p_SoAction,
  _swigc__p_SoActionMethodList,
  _swigc__p_SoAlarmSensor,
  _swigc__p_SoAlphaTest,
  _swigc__p_SoAmbientColorElement,
  _swigc__p_SoAnnoText3CharOrientElement,
  _swigc__p_SoAnnoText3FontSizeHintElement,
  _swigc__p_SoAnnoText3RenderPrintElement,
  _swigc__p_SoAnnotation,
  _swigc__p_SoAntiSquish,
  _swigc__p_SoAppearanceKit,
  _swigc__p_SoArray,
  _swigc__p_SoAsciiText,
  _swigc__p_SoAudioDevice,
  _swigc__p_SoAudioRenderAction,
  _swigc__p_SoAuditorList,
  _swigc__p_SoBBoxModelMatrixElement,
  _swigc__p_SoBase,
  _swigc__p_SoBaseColor,
  _swigc__p_SoBaseKit,
  _swigc__p_SoBaseList,
  _swigc__p_SoBlinker,
  _swigc__p_SoBoolOperation,
  _swigc__p_SoBoundingBoxCache,
  _swigc__p_SoBoxHighlightRenderAction,
  _swigc__p_SoBumpMap,
  _swigc__p_SoBumpMapCoordinate,
  _swigc__p_SoBumpMapCoordinateElement,
  _swigc__p_SoBumpMapElement,
  _swigc__p_SoBumpMapMatrixElement,
  _swigc__p_SoBumpMapTransform,
  _swigc__p_SoBundle,
  _swigc__p_SoButtonEvent,
  _swigc__p_SoByteStream,
  _swigc__p_SoCache,
  _swigc__p_SoCacheElement,
  _swigc__p_SoCacheHint,
  _swigc__p_SoCacheHintElement,
  _swigc__p_SoCalculator,
  _swigc__p_SoCallback,
  _swigc__p_SoCallbackAction,
  _swigc__p_SoCallbackActionCB,
  _swigc__p_SoCallbackList,
  _swigc__p_SoCamera,
  _swigc__p_SoCameraKit,
  _swigc__p_SoCenterballDragger,
  _swigc__p_SoCenterballManip,
  _swigc__p_SoChildList,
  _swigc__p_SoClipPlane,
  _swigc__p_SoClipPlaneElement,
  _swigc__p_SoClipPlaneManip,
  _swigc__p_SoColorIndex,
  _swigc__p_SoColorPacker,
  _swigc__p_SoComplexity,
  _swigc__p_SoComplexityElement,
  _swigc__p_SoComplexityTypeElement,
  _swigc__p_SoComposeMatrix,
  _swigc__p_SoComposeRotation,
  _swigc__p_SoComposeRotationFromTo,
  _swigc__p_SoComposeVec2f,
  _swigc__p_SoComposeVec3f,
  _swigc__p_SoComposeVec4f,
  _swigc__p_SoComputeBoundingBox,
  _swigc__p_SoConcatenate,
  _swigc__p_SoCone,
  _swigc__p_SoConeDetail,
  _swigc__p_SoContextHandler,
  _swigc__p_SoConvexDataCache,
  _swigc__p_SoCoordinate3,
  _swigc__p_SoCoordinate4,
  _swigc__p_SoCoordinateElement,
  _swigc__p_SoCounter,
  _swigc__p_SoCreaseAngleElement,
  _swigc__p_SoCube,
  _swigc__p_SoCubeDetail,
  _swigc__p_SoCullElement,
  _swigc__p_SoCylinder,
  _swigc__p_SoCylinderDetail,
  _swigc__p_SoDB,
  _swigc__p_SoDataSensor,
  _swigc__p_SoDebugError,
  _swigc__p_SoDecimationPercentageElement,
  _swigc__p_SoDecimationTypeElement,
  _swigc__p_SoDecomposeMatrix,
  _swigc__p_SoDecomposeRotation,
  _swigc__p_SoDecomposeVec2f,
  _swigc__p_SoDecomposeVec3f,
  _swigc__p_SoDecomposeVec4f,
  _swigc__p_SoDelayQueueSensor,
  _swigc__p_SoDepthBuffer,
  _swigc__p_SoDepthBufferElement,
  _swigc__p_SoDepthBufferElement__DepthWriteFunction,
  _swigc__p_SoDetail,
  _swigc__p_SoDetailList,
  _swigc__p_SoDiffuseColorElement,
  _swigc__p_SoDirectionalLight,
  _swigc__p_SoDirectionalLightDragger,
  _swigc__p_SoDirectionalLightManip,
  _swigc__p_SoDragPointDragger,
  _swigc__p_SoDragger,
  _swigc__p_SoDrawStyle,
  _swigc__p_SoDrawStyleElement,
  _swigc__p_SoElapsedTime,
  _swigc__p_SoElement,
  _swigc__p_SoEmissiveColorElement,
  _swigc__p_SoEnabledElementsList,
  _swigc__p_SoEngine,
  _swigc__p_SoEngineList,
  _swigc__p_SoEngineOutput,
  _swigc__p_SoEngineOutputData,
  _swigc__p_SoEngineOutputList,
  _swigc__p_SoEnvironment,
  _swigc__p_SoEnvironmentElement,
  _swigc__p_SoError,
  _swigc__p_SoEvent,
  _swigc__p_SoEventCallback,
  _swigc__p_SoEventManager,
  _swigc__p_SoExtSelection,
  _swigc__p_SoFaceDetail,
  _swigc__p_SoFaceSet,
  _swigc__p_SoField,
  _swigc__p_SoFieldContainer,
  _swigc__p_SoFieldConverter,
  _swigc__p_SoFieldData,
  _swigc__p_SoFieldList,
  _swigc__p_SoFieldSensor,
  _swigc__p_SoFile,
  _swigc__p_SoFloatElement,
  _swigc__p_SoFocalDistanceElement,
  _swigc__p_SoFont,
  _swigc__p_SoFontNameElement,
  _swigc__p_SoFontSizeElement,
  _swigc__p_SoFontStyle,
  _swigc__p_SoFragmentShader,
  _swigc__p_SoFrustumCamera,
  _swigc__p_SoFullPath,
  _swigc__p_SoGLBigImage,
  _swigc__p_SoGLCacheContextElement,
  _swigc__p_SoGLCacheList,
  _swigc__p_SoGLClipPlaneElement,
  _swigc__p_SoGLColorIndexElement,
  _swigc__p_SoGLCoordinateElement,
  _swigc__p_SoGLDepthBufferElement,
  _swigc__p_SoGLDisplayList,
  _swigc__p_SoGLDrawStyleElement,
  _swigc__p_SoGLEnvironmentElement,
  _swigc__p_SoGLImage,
  _swigc__p_SoGLImageResizeCB,
  _swigc__p_SoGLLazyElement,
  _swigc__p_SoGLLazyElement__GLState,
  _swigc__p_SoGLLightIdElement,
  _swigc__p_SoGLLinePatternElement,
  _swigc__p_SoGLLineWidthElement,
  _swigc__p_SoGLModelMatrixElement,
  _swigc__p_SoGLMultiTextureCoordinateElement,
  _swigc__p_SoGLMultiTextureEnabledElement,
  _swigc__p_SoGLMultiTextureImageElement,
  _swigc__p_SoGLMultiTextureMatrixElement,
  _swigc__p_SoGLNormalElement,
  _swigc__p_SoGLPointSizeElement,
  _swigc__p_SoGLPolygonOffsetElement,
  _swigc__p_SoGLProjectionMatrixElement,
  _swigc__p_SoGLRenderAbortCB,
  _swigc__p_SoGLRenderAction,
  _swigc__p_SoGLRenderCache,
  _swigc__p_SoGLRenderPassElement,
  _swigc__p_SoGLShaderObject,
  _swigc__p_SoGLShapeHintsElement,
  _swigc__p_SoGLUpdateAreaElement,
  _swigc__p_SoGLVBOElement,
  _swigc__p_SoGLVertexAttributeElement,
  _swigc__p_SoGLViewingMatrixElement,
  _swigc__p_SoGLViewportRegionElement,
  _swigc__p_SoGate,
  _swigc__p_SoGeo,
  _swigc__p_SoGeoCoordinate,
  _swigc__p_SoGeoLocation,
  _swigc__p_SoGeoOrigin,
  _swigc__p_SoGeoSeparator,
  _swigc__p_SoGetBoundingBoxAction,
  _swigc__p_SoGetMatrixAction,
  _swigc__p_SoGetPrimitiveCountAction,
  _swigc__p_SoGlyph,
  _swigc__p_SoGroup,
  _swigc__p_SoHandleBoxDragger,
  _swigc__p_SoHandleBoxManip,
  _swigc__p_SoHandleEventAction,
  _swigc__p_SoHardCopy,
  _swigc__p_SoHeightMapToNormalMap,
  _swigc__p_SoIdleSensor,
  _swigc__p_SoImage,
  _swigc__p_SoIndexedFaceSet,
  _swigc__p_SoIndexedLineSet,
  _swigc__p_SoIndexedMarkerSet,
  _swigc__p_SoIndexedNurbsCurve,
  _swigc__p_SoIndexedNurbsSurface,
  _swigc__p_SoIndexedPointSet,
  _swigc__p_SoIndexedShape,
  _swigc__p_SoIndexedTriangleStripSet,
  _swigc__p_SoInfo,
  _swigc__p_SoInput,
  _swigc__p_SoInt32Element,
  _swigc__p_SoInteraction,
  _swigc__p_SoInteractionKit,
  _swigc__p_SoInterpolate,
  _swigc__p_SoInterpolateFloat,
  _swigc__p_SoInterpolateRotation,
  _swigc__p_SoInterpolateVec2f,
  _swigc__p_SoInterpolateVec3f,
  _swigc__p_SoInterpolateVec4f,
  _swigc__p_SoIntersectingPrimitive,
  _swigc__p_SoIntersectionCB,
  _swigc__p_SoIntersectionDetectionAction,
  _swigc__p_SoIntersectionFilterCB,
  _swigc__p_SoIntersectionVisitationCB,
  _swigc__p_SoJackDragger,
  _swigc__p_SoJackManip,
  _swigc__p_SoKeyboardEvent,
  _swigc__p_SoLOD,
  _swigc__p_SoLabel,
  _swigc__p_SoLazyElement,
  _swigc__p_SoLevelOfDetail,
  _swigc__p_SoLight,
  _swigc__p_SoLightAttenuationElement,
  _swigc__p_SoLightElement,
  _swigc__p_SoLightKit,
  _swigc__p_SoLightModel,
  _swigc__p_SoLightModelElement,
  _swigc__p_SoLightPath,
  _swigc__p_SoLineDetail,
  _swigc__p_SoLineHighlightRenderAction,
  _swigc__p_SoLinePatternElement,
  _swigc__p_SoLineSet,
  _swigc__p_SoLineWidthElement,
  _swigc__p_SoLinearProfile,
  _swigc__p_SoListener,
  _swigc__p_SoListenerDopplerElement,
  _swigc__p_SoListenerGainElement,
  _swigc__p_SoListenerOrientationElement,
  _swigc__p_SoListenerPositionElement,
  _swigc__p_SoLocalBBoxMatrixElement,
  _swigc__p_SoLocateHighlight,
  _swigc__p_SoLocation2Event,
  _swigc__p_SoLockManager,
  _swigc__p_SoMFBitMask,
  _swigc__p_SoMFBool,
  _swigc__p_SoMFColor,
  _swigc__p_SoMFColorRGBA,
  _swigc__p_SoMFDouble,
  _swigc__p_SoMFEngine,
  _swigc__p_SoMFEnum,
  _swigc__p_SoMFFloat,
  _swigc__p_SoMFInt32,
  _swigc__p_SoMFMatrix,
  _swigc__p_SoMFName,
  _swigc__p_SoMFNode,
  _swigc__p_SoMFPath,
  _swigc__p_SoMFPlane,
  _swigc__p_SoMFRotation,
  _swigc__p_SoMFShort,
  _swigc__p_SoMFString,
  _swigc__p_SoMFTime,
  _swigc__p_SoMFUInt32,
  _swigc__p_SoMFUShort,
  _swigc__p_SoMFVec2b,
  _swigc__p_SoMFVec2d,
  _swigc__p_SoMFVec2f,
  _swigc__p_SoMFVec2i32,
  _swigc__p_SoMFVec2s,
  _swigc__p_SoMFVec3b,
  _swigc__p_SoMFVec3d,
  _swigc__p_SoMFVec3f,
  _swigc__p_SoMFVec3i32,
  _swigc__p_SoMFVec3s,
  _swigc__p_SoMFVec4b,
  _swigc__p_SoMFVec4d,
  _swigc__p_SoMFVec4f,
  _swigc__p_SoMFVec4i32,
  _swigc__p_SoMFVec4s,
  _swigc__p_SoMFVec4ub,
  _swigc__p_SoMFVec4ui32,
  _swigc__p_SoMFVec4us,
  _swigc__p_SoMField,
  _swigc__p_SoMarkerSet,
  _swigc__p_SoMaterial,
  _swigc__p_SoMaterialBinding,
  _swigc__p_SoMaterialBindingElement,
  _swigc__p_SoMaterialBundle,
  _swigc__p_SoMatrixTransform,
  _swigc__p_SoMemoryError,
  _swigc__p_SoModelMatrixElement,
  _swigc__p_SoMotion3Event,
  _swigc__p_SoMouseButtonEvent,
  _swigc__p_SoMultiTextureCoordinateElement,
  _swigc__p_SoMultiTextureEnabledElement,
  _swigc__p_SoMultiTextureEnabledElement__Mode,
  _swigc__p_SoMultiTextureImageElement,
  _swigc__p_SoMultiTextureImageElement__Model,
  _swigc__p_SoMultiTextureImageElement__Wrap,
  _swigc__p_SoMultiTextureMatrixElement,
  _swigc__p_SoMultipleCopy,
  _swigc__p_SoNode,
  _swigc__p_SoNodeEngine,
  _swigc__p_SoNodeKit,
  _swigc__p_SoNodeKitDetail,
  _swigc__p_SoNodeKitListPart,
  _swigc__p_SoNodeKitPath,
  _swigc__p_SoNodeList,
  _swigc__p_SoNodeSensor,
  _swigc__p_SoNodekitCatalog,
  _swigc__p_SoNonIndexedShape,
  _swigc__p_SoNormal,
  _swigc__p_SoNormalBinding,
  _swigc__p_SoNormalBindingElement,
  _swigc__p_SoNormalBundle,
  _swigc__p_SoNormalCache,
  _swigc__p_SoNormalElement,
  _swigc__p_SoNormalGenerator,
  _swigc__p_SoNotList,
  _swigc__p_SoNotRec,
  _swigc__p_SoNurbsCurve,
  _swigc__p_SoNurbsProfile,
  _swigc__p_SoNurbsSurface,
  _swigc__p_SoOffscreenRenderer,
  _swigc__p_SoOnOff,
  _swigc__p_SoOneShot,
  _swigc__p_SoOneShotSensor,
  _swigc__p_SoOrthographicCamera,
  _swigc__p_SoOutput,
  _swigc__p_SoOverrideElement,
  _swigc__p_SoPSVectorOutput,
  _swigc__p_SoPackedColor,
  _swigc__p_SoPath,
  _swigc__p_SoPathList,
  _swigc__p_SoPathSensor,
  _swigc__p_SoPathSwitch,
  _swigc__p_SoPendulum,
  _swigc__p_SoPerspectiveCamera,
  _swigc__p_SoPickAction,
  _swigc__p_SoPickRayElement,
  _swigc__p_SoPickStyle,
  _swigc__p_SoPickStyleElement,
  _swigc__p_SoPickedPoint,
  _swigc__p_SoPickedPointList,
  _swigc__p_SoPointDetail,
  _swigc__p_SoPointLight,
  _swigc__p_SoPointLightDragger,
  _swigc__p_SoPointLightManip,
  _swigc__p_SoPointSet,
  _swigc__p_SoPointSizeElement,
  _swigc__p_SoPolygonOffset,
  _swigc__p_SoPolygonOffsetElement,
  _swigc__p_SoPolygonOffsetElement__Style,
  _swigc__p_SoPrimitiveVertex,
  _swigc__p_SoProfile,
  _swigc__p_SoProfileCoordinate2,
  _swigc__p_SoProfileCoordinate3,
  _swigc__p_SoProfileCoordinateElement,
  _swigc__p_SoProfileElement,
  _swigc__p_SoProjectionMatrixElement,
  _swigc__p_SoProto,
  _swigc__p_SoProtoInstance,
  _swigc__p_SoQuadMesh,
  _swigc__p_SoRayPickAction,
  _swigc__p_SoReadError,
  _swigc__p_SoRenderManager,
  _swigc__p_SoRenderManager__Superimposition,
  _swigc__p_SoReorganizeAction,
  _swigc__p_SoReplacedElement,
  _swigc__p_SoResetTransform,
  _swigc__p_SoReversePerspectiveCamera,
  _swigc__p_SoRotateCylindricalDragger,
  _swigc__p_SoRotateDiscDragger,
  _swigc__p_SoRotateSphericalDragger,
  _swigc__p_SoRotation,
  _swigc__p_SoRotationXYZ,
  _swigc__p_SoRotor,
  _swigc__p_SoSFBitMask,
  _swigc__p_SoSFBool,
  _swigc__p_SoSFBox2d,
  _swigc__p_SoSFBox2f,
  _swigc__p_SoSFBox2i32,
  _swigc__p_SoSFBox2s,
  _swigc__p_SoSFBox3d,
  _swigc__p_SoSFBox3f,
  _swigc__p_SoSFBox3i32,
  _swigc__p_SoSFBox3s,
  _swigc__p_SoSFColor,
  _swigc__p_SoSFColorRGBA,
  _swigc__p_SoSFDouble,
  _swigc__p_SoSFEngine,
  _swigc__p_SoSFEnum,
  _swigc__p_SoSFFloat,
  _swigc__p_SoSFImage,
  _swigc__p_SoSFImage3,
  _swigc__p_SoSFInt32,
  _swigc__p_SoSFMatrix,
  _swigc__p_SoSFName,
  _swigc__p_SoSFNode,
  _swigc__p_SoSFPath,
  _swigc__p_SoSFPlane,
  _swigc__p_SoSFRotation,
  _swigc__p_SoSFShort,
  _swigc__p_SoSFString,
  _swigc__p_SoSFTime,
  _swigc__p_SoSFTrigger,
  _swigc__p_SoSFUInt32,
  _swigc__p_SoSFUShort,
  _swigc__p_SoSFVec2b,
  _swigc__p_SoSFVec2d,
  _swigc__p_SoSFVec2f,
  _swigc__p_SoSFVec2i32,
  _swigc__p_SoSFVec2s,
  _swigc__p_SoSFVec3b,
  _swigc__p_SoSFVec3d,
  _swigc__p_SoSFVec3f,
  _swigc__p_SoSFVec3i32,
  _swigc__p_SoSFVec3s,
  _swigc__p_SoSFVec4b,
  _swigc__p_SoSFVec4d,
  _swigc__p_SoSFVec4f,
  _swigc__p_SoSFVec4i32,
  _swigc__p_SoSFVec4s,
  _swigc__p_SoSFVec4ub,
  _swigc__p_SoSFVec4ui32,
  _swigc__p_SoSFVec4us,
  _swigc__p_SoSField,
  _swigc__p_SoScXMLDollyTarget,
  _swigc__p_SoScXMLEvent,
  _swigc__p_SoScXMLFlightControlTarget,
  _swigc__p_SoScXMLMiscTarget,
  _swigc__p_SoScXMLMotionTarget,
  _swigc__p_SoScXMLNavigation,
  _swigc__p_SoScXMLNavigationTarget,
  _swigc__p_SoScXMLPanTarget,
  _swigc__p_SoScXMLRotateTarget,
  _swigc__p_SoScXMLSeekTarget,
  _swigc__p_SoScXMLSpinTarget,
  _swigc__p_SoScXMLStateMachine,
  _swigc__p_SoScXMLZoomTarget,
  _swigc__p_SoScale,
  _swigc__p_SoScale1Dragger,
  _swigc__p_SoScale2Dragger,
  _swigc__p_SoScale2UniformDragger,
  _swigc__p_SoScaleUniformDragger,
  _swigc__p_SoSceneKit,
  _swigc__p_SoSceneManager,
  _swigc__p_SoSceneTexture2,
  _swigc__p_SoSceneTextureCubeMap,
  _swigc__p_SoSearchAction,
  _swigc__p_SoSelectOne,
  _swigc__p_SoSelection,
  _swigc__p_SoSensor,
  _swigc__p_SoSensorManager,
  _swigc__p_SoSeparator,
  _swigc__p_SoSeparatorKit,
  _swigc__p_SoShaderObject,
  _swigc__p_SoShaderParameter,
  _swigc__p_SoShaderParameter1f,
  _swigc__p_SoShaderParameter1i,
  _swigc__p_SoShaderParameter2f,
  _swigc__p_SoShaderParameter2i,
  _swigc__p_SoShaderParameter3f,
  _swigc__p_SoShaderParameter3i,
  _swigc__p_SoShaderParameter4f,
  _swigc__p_SoShaderParameter4i,
  _swigc__p_SoShaderParameterArray1f,
  _swigc__p_SoShaderParameterArray1i,
  _swigc__p_SoShaderParameterArray2f,
  _swigc__p_SoShaderParameterArray2i,
  _swigc__p_SoShaderParameterArray3f,
  _swigc__p_SoShaderParameterArray3i,
  _swigc__p_SoShaderParameterArray4f,
  _swigc__p_SoShaderParameterArray4i,
  _swigc__p_SoShaderParameterMatrix,
  _swigc__p_SoShaderParameterMatrixArray,
  _swigc__p_SoShaderProgram,
  _swigc__p_SoShaderStateMatrixParameter,
  _swigc__p_SoShape,
  _swigc__p_SoShapeHints,
  _swigc__p_SoShapeHintsElement,
  _swigc__p_SoShapeHintsElement__FaceType,
  _swigc__p_SoShapeHintsElement__ShapeType,
  _swigc__p_SoShapeHintsElement__VertexOrdering,
  _swigc__p_SoShapeKit,
  _swigc__p_SoShapeStyleElement,
  _swigc__p_SoShininessElement,
  _swigc__p_SoShuttle,
  _swigc__p_SoSimplifier,
  _swigc__p_SoSimplifyAction,
  _swigc__p_SoSoundElement,
  _swigc__p_SoSpaceballButtonEvent,
  _swigc__p_SoSpecularColorElement,
  _swigc__p_SoSphere,
  _swigc__p_SoSpotLight,
  _swigc__p_SoSpotLightDragger,
  _swigc__p_SoSpotLightManip,
  _swigc__p_SoState,
  _swigc__p_SoSurroundScale,
  _swigc__p_SoSwitch,
  _swigc__p_SoSwitchElement,
  _swigc__p_SoTabBoxDragger,
  _swigc__p_SoTabBoxManip,
  _swigc__p_SoTabPlaneDragger,
  _swigc__p_SoTempPath,
  _swigc__p_SoText2,
  _swigc__p_SoText3,
  _swigc__p_SoTextDetail,
  _swigc__p_SoTextOutlineEnabledElement,
  _swigc__p_SoTexture,
  _swigc__p_SoTexture2,
  _swigc__p_SoTexture2Convert,
  _swigc__p_SoTexture2Transform,
  _swigc__p_SoTexture3,
  _swigc__p_SoTexture3Transform,
  _swigc__p_SoTextureCombine,
  _swigc__p_SoTextureCombineElement,
  _swigc__p_SoTextureCombineElement__Operand,
  _swigc__p_SoTextureCombineElement__Operation,
  _swigc__p_SoTextureCombineElement__Source,
  _swigc__p_SoTextureCoordinate2,
  _swigc__p_SoTextureCoordinate3,
  _swigc__p_SoTextureCoordinateBinding,
  _swigc__p_SoTextureCoordinateBindingElement,
  _swigc__p_SoTextureCoordinateBundle,
  _swigc__p_SoTextureCoordinateCache,
  _swigc__p_SoTextureCoordinateCube,
  _swigc__p_SoTextureCoordinateCylinder,
  _swigc__p_SoTextureCoordinateDefault,
  _swigc__p_SoTextureCoordinateEnvironment,
  _swigc__p_SoTextureCoordinateFunction,
  _swigc__p_SoTextureCoordinateNormalMap,
  _swigc__p_SoTextureCoordinateObject,
  _swigc__p_SoTextureCoordinatePlane,
  _swigc__p_SoTextureCoordinateReflectionMap,
  _swigc__p_SoTextureCoordinateSphere,
  _swigc__p_SoTextureCubeMap,
  _swigc__p_SoTextureMatrixTransform,
  _swigc__p_SoTextureOverrideElement,
  _swigc__p_SoTextureQualityElement,
  _swigc__p_SoTextureScalePolicy,
  _swigc__p_SoTextureUnit,
  _swigc__p_SoTextureUnitElement,
  _swigc__p_SoTimeCounter,
  _swigc__p_SoTimerQueueSensor,
  _swigc__p_SoTimerSensor,
  _swigc__p_SoToVRML2Action,
  _swigc__p_SoToVRMLAction,
  _swigc__p_SoTrackballDragger,
  _swigc__p_SoTrackballManip,
  _swigc__p_SoTranReceiver,
  _swigc__p_SoTranSender,
  _swigc__p_SoTransform,
  _swigc__p_SoTransformBoxDragger,
  _swigc__p_SoTransformBoxManip,
  _swigc__p_SoTransformManip,
  _swigc__p_SoTransformSeparator,
  _swigc__p_SoTransformVec3f,
  _swigc__p_SoTransformation,
  _swigc__p_SoTransformerDragger,
  _swigc__p_SoTransformerManip,
  _swigc__p_SoTranslate1Dragger,
  _swigc__p_SoTranslate2Dragger,
  _swigc__p_SoTranslation,
  _swigc__p_SoTransparencyElement,
  _swigc__p_SoTransparencyType,
  _swigc__p_SoTriangleStripSet,
  _swigc__p_SoTriggerAny,
  _swigc__p_SoType,
  _swigc__p_SoTypeList,
  _swigc__p_SoUniformShaderParameter,
  _swigc__p_SoUnits,
  _swigc__p_SoUnitsElement,
  _swigc__p_SoVBO,
  _swigc__p_SoVRMLAnchor,
  _swigc__p_SoVRMLAppearance,
  _swigc__p_SoVRMLAudioClip,
  _swigc__p_SoVRMLBackground,
  _swigc__p_SoVRMLBillboard,
  _swigc__p_SoVRMLBox,
  _swigc__p_SoVRMLCollision,
  _swigc__p_SoVRMLColor,
  _swigc__p_SoVRMLColorInterpolator,
  _swigc__p_SoVRMLCone,
  _swigc__p_SoVRMLCoordinate,
  _swigc__p_SoVRMLCoordinateInterpolator,
  _swigc__p_SoVRMLCylinder,
  _swigc__p_SoVRMLCylinderSensor,
  _swigc__p_SoVRMLDirectionalLight,
  _swigc__p_SoVRMLDragSensor,
  _swigc__p_SoVRMLElevationGrid,
  _swigc__p_SoVRMLExtrusion,
  _swigc__p_SoVRMLFog,
  _swigc__p_SoVRMLFontStyle,
  _swigc__p_SoVRMLGeometry,
  _swigc__p_SoVRMLGroup,
  _swigc__p_SoVRMLImageTexture,
  _swigc__p_SoVRMLIndexedFaceSet,
  _swigc__p_SoVRMLIndexedLine,
  _swigc__p_SoVRMLIndexedLineSet,
  _swigc__p_SoVRMLIndexedShape,
  _swigc__p_SoVRMLInline,
  _swigc__p_SoVRMLInterpolator,
  _swigc__p_SoVRMLLOD,
  _swigc__p_SoVRMLLight,
  _swigc__p_SoVRMLMaterial,
  _swigc__p_SoVRMLMovieTexture,
  _swigc__p_SoVRMLNavigationInfo,
  _swigc__p_SoVRMLNormal,
  _swigc__p_SoVRMLNormalInterpolator,
  _swigc__p_SoVRMLOrientationInterpolator,
  _swigc__p_SoVRMLParent,
  _swigc__p_SoVRMLPixelTexture,
  _swigc__p_SoVRMLPlaneSensor,
  _swigc__p_SoVRMLPointLight,
  _swigc__p_SoVRMLPointSet,
  _swigc__p_SoVRMLPositionInterpolator,
  _swigc__p_SoVRMLProximitySensor,
  _swigc__p_SoVRMLScalarInterpolator,
  _swigc__p_SoVRMLScript,
  _swigc__p_SoVRMLSensor,
  _swigc__p_SoVRMLShape,
  _swigc__p_SoVRMLSound,
  _swigc__p_SoVRMLSphere,
  _swigc__p_SoVRMLSphereSensor,
  _swigc__p_SoVRMLSpotLight,
  _swigc__p_SoVRMLSwitch,
  _swigc__p_SoVRMLText,
  _swigc__p_SoVRMLTexture,
  _swigc__p_SoVRMLTextureCoordinate,
  _swigc__p_SoVRMLTextureTransform,
  _swigc__p_SoVRMLTimeSensor,
  _swigc__p_SoVRMLTouchSensor,
  _swigc__p_SoVRMLTransform,
  _swigc__p_SoVRMLVertexLine,
  _swigc__p_SoVRMLVertexPoint,
  _swigc__p_SoVRMLVertexShape,
  _swigc__p_SoVRMLViewpoint,
  _swigc__p_SoVRMLVisibilitySensor,
  _swigc__p_SoVRMLWorldInfo,
  _swigc__p_SoVectorOutput,
  _swigc__p_SoVectorizeAction,
  _swigc__p_SoVectorizePSAction,
  _swigc__p_SoVertexAttribute,
  _swigc__p_SoVertexAttributeBinding,
  _swigc__p_SoVertexAttributeBindingElement,
  _swigc__p_SoVertexAttributeData,
  _swigc__p_SoVertexAttributeElement,
  _swigc__p_SoVertexProperty,
  _swigc__p_SoVertexShader,
  _swigc__p_SoVertexShape,
  _swigc__p_SoViewVolumeElement,
  _swigc__p_SoViewingMatrixElement,
  _swigc__p_SoViewportRegionElement,
  _swigc__p_SoWWWAnchor,
  _swigc__p_SoWWWInline,
  _swigc__p_SoWindowElement,
  _swigc__p_SoWrapperKit,
  _swigc__p_SoWriteAction,
  _swigc__p_a_2__double,
  _swigc__p_a_2__doublep,
  _swigc__p_a_2__int,
  _swigc__p_a_2__intp,
  _swigc__p_a_2__short,
  _swigc__p_a_2__signed_char,
  _swigc__p_a_3__int,
  _swigc__p_a_3__intp,
  _swigc__p_a_3__short,
  _swigc__p_a_3__signed_char,
  _swigc__p_a_4__a_4__double,
  _swigc__p_a_4__a_4__doublep,
  _swigc__p_a_4__a_4__float,
  _swigc__p_a_4__a_4__floatp,
  _swigc__p_a_4__double,
  _swigc__p_a_4__doublep,
  _swigc__p_a_4__float,
  _swigc__p_a_4__floatp,
  _swigc__p_a_4__int,
  _swigc__p_a_4__intp,
  _swigc__p_a_4__short,
  _swigc__p_a_4__signed_char,
  _swigc__p_a_4__unsigned_char,
  _swigc__p_a_4__unsigned_int,
  _swigc__p_a_4__unsigned_short,
  _swigc__p_cc_glglue,
  _swigc__p_cc_storage_f,
  _swigc__p_cc_xml_doc,
  _swigc__p_cc_xml_elt,
  _swigc__p_char,
  _swigc__p_charp,
  _swigc__p_close_func,
  _swigc__p_double,
  _swigc__p_doublep,
  _swigc__p_f_char__char,
  _swigc__p_f_char__charp,
  _swigc__p_f_float_p_void__int,
  _swigc__p_f_float_p_void__intp,
  _swigc__p_f_p_SoAction_p_SoNode__void,
  _swigc__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto,
  _swigc__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__int,
  _swigc__p_f_p_SoState_r_q_const__SbVec3s_p_unsigned_char_enum_SoGLImage__ResizeReason_p_void_p_SoGLImage__intp,
  _swigc__p_f_p_q_const__SoError_p_void__void,
  _swigc__p_f_p_void__SoGLRenderAction__AbortCode,
  _swigc__p_f_p_void__float,
  _swigc__p_f_p_void__floatp,
  _swigc__p_f_p_void__int,
  _swigc__p_f_p_void__intp,
  _swigc__p_f_p_void__p_void,
  _swigc__p_f_p_void__void,
  _swigc__p_f_p_void_int__void,
  _swigc__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__int,
  _swigc__p_f_p_void_long_int_p_SoVRMLAudioClip_p_void__intp,
  _swigc__p_f_p_void_p_ScXMLStateMachine__void,
  _swigc__p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void,
  _swigc__p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void,
  _swigc__p_f_p_void_p_SoAction__void,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoNode__SoCallbackAction__Response,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp,
  _swigc__p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void,
  _swigc__p_f_p_void_p_SoDragger__void,
  _swigc__p_f_p_void_p_SoEventCallback__void,
  _swigc__p_f_p_void_p_SoGLRenderAction__float,
  _swigc__p_f_p_void_p_SoGLRenderAction__floatp,
  _swigc__p_f_p_void_p_SoGLRenderAction__void,
  _swigc__p_f_p_void_p_SoInput__void,
  _swigc__p_f_p_void_p_SoPath__void,
  _swigc__p_f_p_void_p_SoRenderManager__void,
  _swigc__p_f_p_void_p_SoSceneManager__void,
  _swigc__p_f_p_void_p_SoSelection__void,
  _swigc__p_f_p_void_p_SoSensor__void,
  _swigc__p_f_p_void_p_SoState_q_const__int__void,
  _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__int,
  _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__intp,
  _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__long,
  _swigc__p_f_p_void_p_SoVRMLAudioClip_p_void__longp,
  _swigc__p_f_p_void_p_SoVRMLScript__void,
  _swigc__p_f_p_void_p_q_const__SoIntersectingPrimitive_p_q_const__SoIntersectingPrimitive__SoIntersectionDetectionAction__Resp,
  _swigc__p_f_p_void_p_q_const__SoPath__SoCallbackAction__Response,
  _swigc__p_f_p_void_p_q_const__SoPath__p_SoFullPath,
  _swigc__p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath,
  _swigc__p_f_p_void_p_q_const__SoPath__p_SoPath,
  _swigc__p_f_p_void_p_q_const__SoPath__p_SoTempPath,
  _swigc__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__int,
  _swigc__p_f_p_void_p_q_const__SoPath_p_q_const__SoPath__intp,
  _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath,
  _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath,
  _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoPath,
  _swigc__p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath,
  _swigc__p_f_p_void_p_void__int,
  _swigc__p_f_p_void_p_void__intp,
  _swigc__p_f_p_void_p_void__void,
  _swigc__p_f_p_void_p_void_int_r_int_p_SoVRMLAudioClip_p_void__size_t,
  _swigc__p_f_p_void_p_void_p_void_p_void__void,
  _swigc__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f,
  _swigc__p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f,
  _swigc__p_f_p_void_size_t__p_void,
  _swigc__p_f_p_void_unsigned_int__void,
  _swigc__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__int,
  _swigc__p_f_q_const__p_void_q_const__p_q_const__SbPlane_q_const__int__intp,
  _swigc__p_f_q_const__p_void_r_q_const__SbBox3f__int,
  _swigc__p_f_q_const__p_void_r_q_const__SbBox3f__intp,
  _swigc__p_f_q_const__p_void_r_q_const__SbSphere__int,
  _swigc__p_f_q_const__p_void_r_q_const__SbSphere__intp,
  _swigc__p_f_q_const__p_void_r_q_const__SbVec3f__int,
  _swigc__p_f_q_const__p_void_r_q_const__SbVec3f__intp,
  _swigc__p_f_q_const__unsigned_int__unsigned_int,
  _swigc__p_f_r_q_const__SbName_float_int_p_void__int,
  _swigc__p_f_r_q_const__SbName_float_int_p_void__intp,
  _swigc__p_f_r_q_const__SbStringList_p_SoVRMLAudioClip_p_void__p_void,
  _swigc__p_f_r_q_const__SbString_p_SbImage_p_void__int,
  _swigc__p_f_r_q_const__SbString_p_SbImage_p_void__intp,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void,
  _swigc__p_f_r_q_const__SbString_p_void_p_SoWWWInline__void,
  _swigc__p_f_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void_r_q_const__SbVec3f_p_void__p_void,
  _swigc__p_f_r_q_const__p_q_const__char_r_q_const__p_SoVertexAttributeData_p_void__void,
  _swigc__p_f_unsigned_int_p_void__void,
  _swigc__p_f_unsigned_int_p_void_p_void__void,
  _swigc__p_f_void__p_void,
  _swigc__p_float,
  _swigc__p_floatp,
  _swigc__p_int,
  _swigc__p_intp,
  _swigc__p_long,
  _swigc__p_long_long,
  _swigc__p_longp,
  _swigc__p_open_func,
  _swigc__p_p_SbName,
  _swigc__p_p_SbString,
  _swigc__p_p_SbVec2f,
  _swigc__p_p_ScXMLAddOpExprDataObj,
  _swigc__p_p_ScXMLAndOpExprDataObj,
  _swigc__p_p_ScXMLAppendOpExprDataObj,
  _swigc__p_p_ScXMLBoolDataObj,
  _swigc__p_p_ScXMLCoinAddOpExprDataObj,
  _swigc__p_p_ScXMLCoinDivideOpExprDataObj,
  _swigc__p_p_ScXMLCoinEqualsOpExprDataObj,
  _swigc__p_p_ScXMLCoinLengthFuncExprDataObj,
  _swigc__p_p_ScXMLCoinMultiplyOpExprDataObj,
  _swigc__p_p_ScXMLCoinSubtractOpExprDataObj,
  _swigc__p_p_ScXMLConstantDataObj,
  _swigc__p_p_ScXMLDataObj,
  _swigc__p_p_ScXMLDivideOpExprDataObj,
  _swigc__p_p_ScXMLEqualsOpExprDataObj,
  _swigc__p_p_ScXMLExprDataObj,
  _swigc__p_p_ScXMLInExprDataObj,
  _swigc__p_p_ScXMLMinimumExprDataObj,
  _swigc__p_p_ScXMLMultiplyOpExprDataObj,
  _swigc__p_p_ScXMLNegateOpExprDataObj,
  _swigc__p_p_ScXMLNotOpExprDataObj,
  _swigc__p_p_ScXMLOrOpExprDataObj,
  _swigc__p_p_ScXMLRealDataObj,
  _swigc__p_p_ScXMLReferenceDataObj,
  _swigc__p_p_ScXMLSbDataObj,
  _swigc__p_p_ScXMLStringDataObj,
  _swigc__p_p_ScXMLSubtractOpExprDataObj,
  _swigc__p_p_ScXMLXMLDataObj,
  _swigc__p_p_SoAlphaTest,
  _swigc__p_p_SoAnnotation,
  _swigc__p_p_SoAntiSquish,
  _swigc__p_p_SoAppearanceKit,
  _swigc__p_p_SoArray,
  _swigc__p_p_SoAsciiText,
  _swigc__p_p_SoBase,
  _swigc__p_p_SoBaseColor,
  _swigc__p_p_SoBaseKit,
  _swigc__p_p_SoBlinker,
  _swigc__p_p_SoBoolOperation,
  _swigc__p_p_SoBoxHighlightRenderAction,
  _swigc__p_p_SoBumpMap,
  _swigc__p_p_SoBumpMapCoordinate,
  _swigc__p_p_SoBumpMapTransform,
  _swigc__p_p_SoCacheHint,
  _swigc__p_p_SoCalculator,
  _swigc__p_p_SoCallback,
  _swigc__p_p_SoCamera,
  _swigc__p_p_SoCameraKit,
  _swigc__p_p_SoCenterballDragger,
  _swigc__p_p_SoCenterballManip,
  _swigc__p_p_SoClipPlane,
  _swigc__p_p_SoClipPlaneManip,
  _swigc__p_p_SoColorIndex,
  _swigc__p_p_SoComplexity,
  _swigc__p_p_SoComposeMatrix,
  _swigc__p_p_SoComposeRotation,
  _swigc__p_p_SoComposeRotationFromTo,
  _swigc__p_p_SoComposeVec2f,
  _swigc__p_p_SoComposeVec3f,
  _swigc__p_p_SoComposeVec4f,
  _swigc__p_p_SoComputeBoundingBox,
  _swigc__p_p_SoConcatenate,
  _swigc__p_p_SoCone,
  _swigc__p_p_SoCoordinate3,
  _swigc__p_p_SoCoordinate4,
  _swigc__p_p_SoCounter,
  _swigc__p_p_SoCube,
  _swigc__p_p_SoCylinder,
  _swigc__p_p_SoDecomposeMatrix,
  _swigc__p_p_SoDecomposeRotation,
  _swigc__p_p_SoDecomposeVec2f,
  _swigc__p_p_SoDecomposeVec3f,
  _swigc__p_p_SoDecomposeVec4f,
  _swigc__p_p_SoDepthBuffer,
  _swigc__p_p_SoDirectionalLight,
  _swigc__p_p_SoDirectionalLightDragger,
  _swigc__p_p_SoDirectionalLightManip,
  _swigc__p_p_SoDragPointDragger,
  _swigc__p_p_SoDragger,
  _swigc__p_p_SoDrawStyle,
  _swigc__p_p_SoElapsedTime,
  _swigc__p_p_SoEngine,
  _swigc__p_p_SoEngineOutput,
  _swigc__p_p_SoEnvironment,
  _swigc__p_p_SoEventCallback,
  _swigc__p_p_SoExtSelection,
  _swigc__p_p_SoFaceSet,
  _swigc__p_p_SoField,
  _swigc__p_p_SoFieldContainer,
  _swigc__p_p_SoFieldConverter,
  _swigc__p_p_SoFile,
  _swigc__p_p_SoFont,
  _swigc__p_p_SoFontStyle,
  _swigc__p_p_SoFragmentShader,
  _swigc__p_p_SoFrustumCamera,
  _swigc__p_p_SoFullPath,
  _swigc__p_p_SoGLRenderAction,
  _swigc__p_p_SoGate,
  _swigc__p_p_SoGeoCoordinate,
  _swigc__p_p_SoGeoLocation,
  _swigc__p_p_SoGeoOrigin,
  _swigc__p_p_SoGeoSeparator,
  _swigc__p_p_SoGroup,
  _swigc__p_p_SoHandleBoxDragger,
  _swigc__p_p_SoHandleBoxManip,
  _swigc__p_p_SoHeightMapToNormalMap,
  _swigc__p_p_SoImage,
  _swigc__p_p_SoIndexedFaceSet,
  _swigc__p_p_SoIndexedLineSet,
  _swigc__p_p_SoIndexedMarkerSet,
  _swigc__p_p_SoIndexedNurbsCurve,
  _swigc__p_p_SoIndexedNurbsSurface,
  _swigc__p_p_SoIndexedPointSet,
  _swigc__p_p_SoIndexedShape,
  _swigc__p_p_SoIndexedTriangleStripSet,
  _swigc__p_p_SoInfo,
  _swigc__p_p_SoInteractionKit,
  _swigc__p_p_SoInterpolate,
  _swigc__p_p_SoInterpolateFloat,
  _swigc__p_p_SoInterpolateRotation,
  _swigc__p_p_SoInterpolateVec2f,
  _swigc__p_p_SoInterpolateVec3f,
  _swigc__p_p_SoInterpolateVec4f,
  _swigc__p_p_SoJackDragger,
  _swigc__p_p_SoJackManip,
  _swigc__p_p_SoLOD,
  _swigc__p_p_SoLabel,
  _swigc__p_p_SoLevelOfDetail,
  _swigc__p_p_SoLight,
  _swigc__p_p_SoLightKit,
  _swigc__p_p_SoLightModel,
  _swigc__p_p_SoLineHighlightRenderAction,
  _swigc__p_p_SoLineSet,
  _swigc__p_p_SoLinearProfile,
  _swigc__p_p_SoListener,
  _swigc__p_p_SoLocateHighlight,
  _swigc__p_p_SoMFBitMask,
  _swigc__p_p_SoMFBool,
  _swigc__p_p_SoMFColor,
  _swigc__p_p_SoMFColorRGBA,
  _swigc__p_p_SoMFDouble,
  _swigc__p_p_SoMFEngine,
  _swigc__p_p_SoMFEnum,
  _swigc__p_p_SoMFFloat,
  _swigc__p_p_SoMFInt32,
  _swigc__p_p_SoMFMatrix,
  _swigc__p_p_SoMFName,
  _swigc__p_p_SoMFNode,
  _swigc__p_p_SoMFPath,
  _swigc__p_p_SoMFPlane,
  _swigc__p_p_SoMFRotation,
  _swigc__p_p_SoMFShort,
  _swigc__p_p_SoMFString,
  _swigc__p_p_SoMFTime,
  _swigc__p_p_SoMFUInt32,
  _swigc__p_p_SoMFUShort,
  _swigc__p_p_SoMFVec2b,
  _swigc__p_p_SoMFVec2d,
  _swigc__p_p_SoMFVec2f,
  _swigc__p_p_SoMFVec2i32,
  _swigc__p_p_SoMFVec2s,
  _swigc__p_p_SoMFVec3b,
  _swigc__p_p_SoMFVec3d,
  _swigc__p_p_SoMFVec3f,
  _swigc__p_p_SoMFVec3i32,
  _swigc__p_p_SoMFVec3s,
  _swigc__p_p_SoMFVec4b,
  _swigc__p_p_SoMFVec4d,
  _swigc__p_p_SoMFVec4f,
  _swigc__p_p_SoMFVec4i32,
  _swigc__p_p_SoMFVec4s,
  _swigc__p_p_SoMFVec4ub,
  _swigc__p_p_SoMFVec4ui32,
  _swigc__p_p_SoMFVec4us,
  _swigc__p_p_SoMField,
  _swigc__p_p_SoMarkerSet,
  _swigc__p_p_SoMaterial,
  _swigc__p_p_SoMaterialBinding,
  _swigc__p_p_SoMatrixTransform,
  _swigc__p_p_SoMultipleCopy,
  _swigc__p_p_SoNode,
  _swigc__p_p_SoNodeEngine,
  _swigc__p_p_SoNodeKitListPart,
  _swigc__p_p_SoNodeKitPath,
  _swigc__p_p_SoNonIndexedShape,
  _swigc__p_p_SoNormal,
  _swigc__p_p_SoNormalBinding,
  _swigc__p_p_SoNurbsCurve,
  _swigc__p_p_SoNurbsProfile,
  _swigc__p_p_SoNurbsSurface,
  _swigc__p_p_SoOnOff,
  _swigc__p_p_SoOneShot,
  _swigc__p_p_SoOrthographicCamera,
  _swigc__p_p_SoPackedColor,
  _swigc__p_p_SoPath,
  _swigc__p_p_SoPathSwitch,
  _swigc__p_p_SoPendulum,
  _swigc__p_p_SoPerspectiveCamera,
  _swigc__p_p_SoPickStyle,
  _swigc__p_p_SoPointLight,
  _swigc__p_p_SoPointLightDragger,
  _swigc__p_p_SoPointLightManip,
  _swigc__p_p_SoPointSet,
  _swigc__p_p_SoPolygonOffset,
  _swigc__p_p_SoProfile,
  _swigc__p_p_SoProfileCoordinate2,
  _swigc__p_p_SoProfileCoordinate3,
  _swigc__p_p_SoProto,
  _swigc__p_p_SoProtoInstance,
  _swigc__p_p_SoQuadMesh,
  _swigc__p_p_SoResetTransform,
  _swigc__p_p_SoReversePerspectiveCamera,
  _swigc__p_p_SoRotateCylindricalDragger,
  _swigc__p_p_SoRotateDiscDragger,
  _swigc__p_p_SoRotateSphericalDragger,
  _swigc__p_p_SoRotation,
  _swigc__p_p_SoRotationXYZ,
  _swigc__p_p_SoRotor,
  _swigc__p_p_SoSFBitMask,
  _swigc__p_p_SoSFBool,
  _swigc__p_p_SoSFBox2d,
  _swigc__p_p_SoSFBox2f,
  _swigc__p_p_SoSFBox2i32,
  _swigc__p_p_SoSFBox2s,
  _swigc__p_p_SoSFBox3d,
  _swigc__p_p_SoSFBox3f,
  _swigc__p_p_SoSFBox3i32,
  _swigc__p_p_SoSFBox3s,
  _swigc__p_p_SoSFColor,
  _swigc__p_p_SoSFColorRGBA,
  _swigc__p_p_SoSFDouble,
  _swigc__p_p_SoSFEngine,
  _swigc__p_p_SoSFEnum,
  _swigc__p_p_SoSFFloat,
  _swigc__p_p_SoSFImage,
  _swigc__p_p_SoSFImage3,
  _swigc__p_p_SoSFInt32,
  _swigc__p_p_SoSFMatrix,
  _swigc__p_p_SoSFName,
  _swigc__p_p_SoSFNode,
  _swigc__p_p_SoSFPath,
  _swigc__p_p_SoSFPlane,
  _swigc__p_p_SoSFRotation,
  _swigc__p_p_SoSFShort,
  _swigc__p_p_SoSFString,
  _swigc__p_p_SoSFTime,
  _swigc__p_p_SoSFTrigger,
  _swigc__p_p_SoSFUInt32,
  _swigc__p_p_SoSFUShort,
  _swigc__p_p_SoSFVec2b,
  _swigc__p_p_SoSFVec2d,
  _swigc__p_p_SoSFVec2f,
  _swigc__p_p_SoSFVec2i32,
  _swigc__p_p_SoSFVec2s,
  _swigc__p_p_SoSFVec3b,
  _swigc__p_p_SoSFVec3d,
  _swigc__p_p_SoSFVec3f,
  _swigc__p_p_SoSFVec3i32,
  _swigc__p_p_SoSFVec3s,
  _swigc__p_p_SoSFVec4b,
  _swigc__p_p_SoSFVec4d,
  _swigc__p_p_SoSFVec4f,
  _swigc__p_p_SoSFVec4i32,
  _swigc__p_p_SoSFVec4s,
  _swigc__p_p_SoSFVec4ub,
  _swigc__p_p_SoSFVec4ui32,
  _swigc__p_p_SoSFVec4us,
  _swigc__p_p_SoSField,
  _swigc__p_p_SoScale,
  _swigc__p_p_SoScale1Dragger,
  _swigc__p_p_SoScale2Dragger,
  _swigc__p_p_SoScale2UniformDragger,
  _swigc__p_p_SoScaleUniformDragger,
  _swigc__p_p_SoSceneKit,
  _swigc__p_p_SoSceneTexture2,
  _swigc__p_p_SoSceneTextureCubeMap,
  _swigc__p_p_SoSelectOne,
  _swigc__p_p_SoSelection,
  _swigc__p_p_SoSeparator,
  _swigc__p_p_SoSeparatorKit,
  _swigc__p_p_SoShaderObject,
  _swigc__p_p_SoShaderParameter,
  _swigc__p_p_SoShaderParameter1f,
  _swigc__p_p_SoShaderParameter1i,
  _swigc__p_p_SoShaderParameter2f,
  _swigc__p_p_SoShaderParameter2i,
  _swigc__p_p_SoShaderParameter3f,
  _swigc__p_p_SoShaderParameter3i,
  _swigc__p_p_SoShaderParameter4f,
  _swigc__p_p_SoShaderParameter4i,
  _swigc__p_p_SoShaderParameterArray1f,
  _swigc__p_p_SoShaderParameterArray1i,
  _swigc__p_p_SoShaderParameterArray2f,
  _swigc__p_p_SoShaderParameterArray2i,
  _swigc__p_p_SoShaderParameterArray3f,
  _swigc__p_p_SoShaderParameterArray3i,
  _swigc__p_p_SoShaderParameterArray4f,
  _swigc__p_p_SoShaderParameterArray4i,
  _swigc__p_p_SoShaderParameterMatrix,
  _swigc__p_p_SoShaderParameterMatrixArray,
  _swigc__p_p_SoShaderProgram,
  _swigc__p_p_SoShaderStateMatrixParameter,
  _swigc__p_p_SoShape,
  _swigc__p_p_SoShapeHints,
  _swigc__p_p_SoShapeKit,
  _swigc__p_p_SoShuttle,
  _swigc__p_p_SoSphere,
  _swigc__p_p_SoSpotLight,
  _swigc__p_p_SoSpotLightDragger,
  _swigc__p_p_SoSpotLightManip,
  _swigc__p_p_SoSurroundScale,
  _swigc__p_p_SoSwitch,
  _swigc__p_p_SoTabBoxDragger,
  _swigc__p_p_SoTabBoxManip,
  _swigc__p_p_SoTabPlaneDragger,
  _swigc__p_p_SoTempPath,
  _swigc__p_p_SoText2,
  _swigc__p_p_SoText3,
  _swigc__p_p_SoTexture,
  _swigc__p_p_SoTexture2,
  _swigc__p_p_SoTexture2Convert,
  _swigc__p_p_SoTexture2Transform,
  _swigc__p_p_SoTexture3,
  _swigc__p_p_SoTexture3Transform,
  _swigc__p_p_SoTextureCombine,
  _swigc__p_p_SoTextureCoordinate2,
  _swigc__p_p_SoTextureCoordinate3,
  _swigc__p_p_SoTextureCoordinateBinding,
  _swigc__p_p_SoTextureCoordinateCube,
  _swigc__p_p_SoTextureCoordinateCylinder,
  _swigc__p_p_SoTextureCoordinateDefault,
  _swigc__p_p_SoTextureCoordinateEnvironment,
  _swigc__p_p_SoTextureCoordinateFunction,
  _swigc__p_p_SoTextureCoordinateNormalMap,
  _swigc__p_p_SoTextureCoordinateObject,
  _swigc__p_p_SoTextureCoordinatePlane,
  _swigc__p_p_SoTextureCoordinateReflectionMap,
  _swigc__p_p_SoTextureCoordinateSphere,
  _swigc__p_p_SoTextureCubeMap,
  _swigc__p_p_SoTextureMatrixTransform,
  _swigc__p_p_SoTextureScalePolicy,
  _swigc__p_p_SoTextureUnit,
  _swigc__p_p_SoTimeCounter,
  _swigc__p_p_SoTrackballDragger,
  _swigc__p_p_SoTrackballManip,
  _swigc__p_p_SoTransform,
  _swigc__p_p_SoTransformBoxDragger,
  _swigc__p_p_SoTransformBoxManip,
  _swigc__p_p_SoTransformManip,
  _swigc__p_p_SoTransformSeparator,
  _swigc__p_p_SoTransformVec3f,
  _swigc__p_p_SoTransformation,
  _swigc__p_p_SoTransformerDragger,
  _swigc__p_p_SoTransformerManip,
  _swigc__p_p_SoTranslate1Dragger,
  _swigc__p_p_SoTranslate2Dragger,
  _swigc__p_p_SoTranslation,
  _swigc__p_p_SoTransparencyType,
  _swigc__p_p_SoTriangleStripSet,
  _swigc__p_p_SoTriggerAny,
  _swigc__p_p_SoUniformShaderParameter,
  _swigc__p_p_SoUnits,
  _swigc__p_p_SoVRMLAnchor,
  _swigc__p_p_SoVRMLAppearance,
  _swigc__p_p_SoVRMLAudioClip,
  _swigc__p_p_SoVRMLBackground,
  _swigc__p_p_SoVRMLBillboard,
  _swigc__p_p_SoVRMLBox,
  _swigc__p_p_SoVRMLCollision,
  _swigc__p_p_SoVRMLColor,
  _swigc__p_p_SoVRMLColorInterpolator,
  _swigc__p_p_SoVRMLCone,
  _swigc__p_p_SoVRMLCoordinate,
  _swigc__p_p_SoVRMLCoordinateInterpolator,
  _swigc__p_p_SoVRMLCylinder,
  _swigc__p_p_SoVRMLCylinderSensor,
  _swigc__p_p_SoVRMLDirectionalLight,
  _swigc__p_p_SoVRMLDragSensor,
  _swigc__p_p_SoVRMLElevationGrid,
  _swigc__p_p_SoVRMLExtrusion,
  _swigc__p_p_SoVRMLFog,
  _swigc__p_p_SoVRMLFontStyle,
  _swigc__p_p_SoVRMLGeometry,
  _swigc__p_p_SoVRMLGroup,
  _swigc__p_p_SoVRMLImageTexture,
  _swigc__p_p_SoVRMLIndexedFaceSet,
  _swigc__p_p_SoVRMLIndexedLine,
  _swigc__p_p_SoVRMLIndexedLineSet,
  _swigc__p_p_SoVRMLIndexedShape,
  _swigc__p_p_SoVRMLInline,
  _swigc__p_p_SoVRMLInterpolator,
  _swigc__p_p_SoVRMLLOD,
  _swigc__p_p_SoVRMLLight,
  _swigc__p_p_SoVRMLMaterial,
  _swigc__p_p_SoVRMLMovieTexture,
  _swigc__p_p_SoVRMLNavigationInfo,
  _swigc__p_p_SoVRMLNormal,
  _swigc__p_p_SoVRMLNormalInterpolator,
  _swigc__p_p_SoVRMLOrientationInterpolator,
  _swigc__p_p_SoVRMLParent,
  _swigc__p_p_SoVRMLPixelTexture,
  _swigc__p_p_SoVRMLPlaneSensor,
  _swigc__p_p_SoVRMLPointLight,
  _swigc__p_p_SoVRMLPointSet,
  _swigc__p_p_SoVRMLPositionInterpolator,
  _swigc__p_p_SoVRMLProximitySensor,
  _swigc__p_p_SoVRMLScalarInterpolator,
  _swigc__p_p_SoVRMLScript,
  _swigc__p_p_SoVRMLSensor,
  _swigc__p_p_SoVRMLShape,
  _swigc__p_p_SoVRMLSound,
  _swigc__p_p_SoVRMLSphere,
  _swigc__p_p_SoVRMLSphereSensor,
  _swigc__p_p_SoVRMLSpotLight,
  _swigc__p_p_SoVRMLSwitch,
  _swigc__p_p_SoVRMLText,
  _swigc__p_p_SoVRMLTexture,
  _swigc__p_p_SoVRMLTextureCoordinate,
  _swigc__p_p_SoVRMLTextureTransform,
  _swigc__p_p_SoVRMLTimeSensor,
  _swigc__p_p_SoVRMLTouchSensor,
  _swigc__p_p_SoVRMLTransform,
  _swigc__p_p_SoVRMLVertexLine,
  _swigc__p_p_SoVRMLVertexPoint,
  _swigc__p_p_SoVRMLVertexShape,
  _swigc__p_p_SoVRMLViewpoint,
  _swigc__p_p_SoVRMLVisibilitySensor,
  _swigc__p_p_SoVRMLWorldInfo,
  _swigc__p_p_SoVertexAttribute,
  _swigc__p_p_SoVertexAttributeBinding,
  _swigc__p_p_SoVertexProperty,
  _swigc__p_p_SoVertexShader,
  _swigc__p_p_SoVertexShape,
  _swigc__p_p_SoWWWAnchor,
  _swigc__p_p_SoWWWInline,
  _swigc__p_p_SoWrapperKit,
  _swigc__p_p_char,
  _swigc__p_p_charp,
  _swigc__p_p_f_p_SoAction_p_SoNode__void,
  _swigc__p_p_f_p_void__SoGLRenderAction__AbortCode,
  _swigc__p_p_f_p_void_p_SoInput__void,
  _swigc__p_p_float,
  _swigc__p_p_floatp,
  _swigc__p_p_int,
  _swigc__p_p_intp,
  _swigc__p_p_unsigned_char,
  _swigc__p_p_void,
  _swigc__p_read_func,
  _swigc__p_seek_func,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_size_t,
  _swigc__p_std__FILE,
  _swigc__p_tell_func,
  _swigc__p_time_t,
  _swigc__p_timeval,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_void,
  _swigc__p_wchar_t,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is made tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast dependencies. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns.
 *
 * We loop through the cast[] array associated with the type and mark casts
 * which have not been defined in previously loaded modules by assigning
 * cast pointer value to cast->next. We also hash cast->type->name string
 * and store the value in the cast->value field. If we encounter swig_cast_info
 * structure that represents a cast to self we move it to the beginning
 * of the cast array. One trick we need to do is making sure the type pointer
 * in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the list (because the cast->type) pointer will
 *     be correct.
 *
 * Once the cast array has been set up AND it does have new casts that need
 * to be added we sort non-self cast entries to move filtered out entries
 * to the end of the array and to arrange the rest in the increasing order
 * of their type pointer values. We store the index of the last added entry
 * in the cast->value field of the entry[0] (overwriting the name hash). Then
 * we sort <next|value> fields of the remaining entries to arrange hash values
 * in the increasing order. This way cast->next->type->name field matches
 * the cast->value hash.
 *
 * Example:
 * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
 * has already been loaded
 *
 *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
 *        ________________       ________________       ________________
 *       |                |     |                |     |                |
 * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
 *   0   |                |     |                |     |                |
 *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
 *       | value = 1212   |     | value = 3      |     | value = 3      |
 *       |                |     |                |     |                |
 *       |================|     |================|     |================|
 *       |                |     |                |     |                |
 * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
 *   1   |                |     |                |     |                |
 *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
 *       | value = 3434   |     | value = 4545   |     | value = 2323   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
 *   2   |                |     |                |     |                |
 *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
 *       | value = 0      |     | value = 3434   |     | value = 3434   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
 *   3   |                |     |                |     |                |
 *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
 *       | value = 4545   |     | value = 2323   |     | value = 4545   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
 *   4   |                |     |                |     |                |
 *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
 *       | value = 2323   |     | value = 0      |     | value = 0      |
 *       |________________|     |________________|     |________________|
 *
 * Once the cast array has been initialized, we use cast[0]->next field to link
 * it into the list of cast arrays for the type.
 *              ____    ____    ____
 * type->cast->|next|->|next|->|next|->0
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *
 * Subsequent cast resolution works as follows:
 *
 * 1. Check whether the type matches the first entry in the current cast array.
 * 2. If not, then do a binary search over the (0:cast->value] interval using
 *    either type address or the hash value of the type name.
 * 3. If not found, then move over to the next cast array (cast[0]->next).
 *
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

/*
 * Sort function that puts cast entries with nonzero 'next' at the front
 * of the array while ordering them by addresses of their 'type' structs.
 */
SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
  swig_cast_info *pca = (swig_cast_info *)pa;
  swig_cast_info *pcb = (swig_cast_info *)pb;
  if (pca->type < pcb->type)
  return (pca->next || pcb->next == 0) ? -1 : 1;
  if (pca->type > pcb->type)
  return (pcb->next || pca->next == 0) ? 1 : -1;
  return 0;
}

/*
 * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
 */
SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
  const int hmax = size/9;
  int h, i;
  for(h = 1; h <= hmax; h = 3*h+1);
  for(; h > 0; h /= 3)
  {
    for(i = h; i < size; ++i)
    {
      swig_cast_info *p = cast[i].next;
      unsigned int hash = cast[i].value;
      int j = i;
      while(j >= h && hash < cast[j-h].value)
      {
        cast[j].next = cast[j-h].next;
        cast[j].value = cast[j-h].value;
        j -= h;
      }
      cast[j].next = p;
      cast[j].value = hash;
    }
  }
}

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *target_type;
    swig_cast_info *cast, *first;
    int num_mapped = 0;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = first = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      target_type = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
        if (target_type) {
          /* Target type already defined in another module */
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
#endif
          if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
#endif
            cast->type = target_type;
            target_type = 0;
          } else {
            /* Check if this cast is already in the list */
            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
#ifdef SWIGRUNTIME_DEBUG
            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
#endif
            if (!ocast) target_type = 0;
          }
        }
      }
      
      if (!target_type) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        /* Set inclusion mark for sorting */
        cast->next = cast;
        num_mapped++;
        
        if (type == cast->type) {
#ifdef SWIGRUNTIME_DEBUG
          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
#endif
          if (cast - first) {
            /* Move cast to itself to the first entry in the array */
            
            swig_cast_info tmp = *cast;
            *cast = *first;
            *first = tmp;
          }
          first++;
          
        } else {
          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
        }
      }
      cast++;
    }
    
    if (num_mapped) {
      if (cast - first) {
        swig_cast_info *tmp;
        
        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
        qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct);
        
        /* Remap back links for added entries */
        cast = swig_module.cast_initial[i] + num_mapped;
        for (tmp = first; tmp < cast; tmp++) {
          tmp->next = tmp;
        }
      }
      
      /* Set the value field of the first entry to the index of the last added entry */
      cast = swig_module.cast_initial[i];
      cast->value = num_mapped - 1;
      
      num_mapped -= (int)(first - cast);
      if (num_mapped > 1) {
        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
        
        SWIG_CastHashSort(first, num_mapped);
      }
      
      first = type->cast;
      if (first) {
        /* Link the current set into the list of cast arrays */
        cast->next = first->next;
        first->next = cast;
      } else {
        cast->next = 0;
        type->cast = cast;
      }
    }
    
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      swig_cast_info *head, *cast;
      head = swig_module.types[i]->cast;
      while (head) {
        for (cast = head; (cast - head) <= head->value; cast++) {
          if (!cast->converter) {
            if (cast->type && !cast->type->clientdata)
            SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
          }
        }
        head = head->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

SWIGINTERN int SWIG_mod_exec(PyObject *module);

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
#if PY_VERSION_HEX >= 0x03000000
  static PyModuleDef_Slot SwigSlots[] = {
    {
      Py_mod_exec, (void *)SWIG_mod_exec 
    },
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
    {
      Py_mod_gil, Py_MOD_GIL_NOT_USED 
    },
#endif
#endif
    {
      0, NULL 
    }
  };
  
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    0,
    SwigMethods,
    SwigSlots,
    NULL,
    NULL,
    NULL
  };
  
  return PyModuleDef_Init(&SWIG_module);
#else
  PyObject *m = Py_InitModule(SWIG_name, SwigMethods);
  if (m && SWIG_mod_exec(m) != 0) {
    Py_DECREF(m);
  }
#endif
}

SWIGINTERN int SWIG_mod_exec(PyObject *m) {
  PyObject *d, *md, *globals;
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType_Type();
  assert(metatype);
  
  SwigPyStaticVar_Type();
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_Type();
  SwigVarLink_Type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_Type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
  PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
#endif
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
    return -1;
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
#if PY_MAJOR_VERSION >= 3
  if (init_file_emulator() < 0) {
#if (SWIG_VERSION < 0x040400)
    return NULL;
#else
    return 0;
#endif
  }
#endif
  
  SWIG_Python_SetConstant(d, "FALSE",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "TRUE",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INTTYPES_H",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_STDINT_H",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_SYS_TYPES_H",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_STDDEF_H",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INT8_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_UINT8_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INT16_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_UINT16_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INT32_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_UINT32_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INT64_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_UINT64_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_INTPTR_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "HAVE_UINTPTR_T",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "M_E",SWIG_From_double(static_cast< double >(2.7182818284590452354)));
  SWIG_Python_SetConstant(d, "M_LOG2E",SWIG_From_double(static_cast< double >(1.4426950408889634074)));
  SWIG_Python_SetConstant(d, "M_LOG10E",SWIG_From_double(static_cast< double >(0.43429448190325182765)));
  SWIG_Python_SetConstant(d, "M_LN2",SWIG_From_double(static_cast< double >(0.69314718055994530942)));
  SWIG_Python_SetConstant(d, "M_LN10",SWIG_From_double(static_cast< double >(2.30258509299404568402)));
  SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
  SWIG_Python_SetConstant(d, "M_TWOPI",SWIG_From_double(static_cast< double >((3.14159265358979323846*2.0))));
  SWIG_Python_SetConstant(d, "M_PI_2",SWIG_From_double(static_cast< double >(1.57079632679489661923)));
  SWIG_Python_SetConstant(d, "M_PI_4",SWIG_From_double(static_cast< double >(0.78539816339744830962)));
  SWIG_Python_SetConstant(d, "M_3PI_4",SWIG_From_double(static_cast< double >(2.3561944901923448370E0)));
  SWIG_Python_SetConstant(d, "M_SQRTPI",SWIG_From_double(static_cast< double >(1.77245385090551602792981)));
  SWIG_Python_SetConstant(d, "M_1_PI",SWIG_From_double(static_cast< double >(0.31830988618379067154)));
  SWIG_Python_SetConstant(d, "M_2_PI",SWIG_From_double(static_cast< double >(0.63661977236758134308)));
  SWIG_Python_SetConstant(d, "M_2_SQRTPI",SWIG_From_double(static_cast< double >(1.12837916709551257390)));
  SWIG_Python_SetConstant(d, "M_SQRT2",SWIG_From_double(static_cast< double >(1.41421356237309504880)));
  SWIG_Python_SetConstant(d, "M_SQRT1_2",SWIG_From_double(static_cast< double >(0.70710678118654752440)));
  SWIG_Python_SetConstant(d, "M_LN2LO",SWIG_From_double(static_cast< double >(1.9082149292705877000E-10)));
  SWIG_Python_SetConstant(d, "M_LN2HI",SWIG_From_double(static_cast< double >(6.9314718036912381649E-1)));
  SWIG_Python_SetConstant(d, "M_SQRT3",SWIG_From_double(static_cast< double >(1.73205080756887719000)));
  SWIG_Python_SetConstant(d, "M_IVLN10",SWIG_From_double(static_cast< double >(0.43429448190325182765)));
  SWIG_Python_SetConstant(d, "M_LOG2_E",SWIG_From_double(static_cast< double >(0.693147180559945309417)));
  SWIG_Python_SetConstant(d, "M_INVLN2",SWIG_From_double(static_cast< double >(1.4426950408889633870E0)));
  SWIG_Python_SetConstant(d, "COIN_MAJOR_VERSION",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "COIN_MINOR_VERSION",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "COIN_MICRO_VERSION",SWIG_From_int(static_cast< int >(8)));
  SWIG_Python_SetConstant(d, "COIN_VERSION",SWIG_FromCharPtr("4.0.8"));
  SWIG_Python_SetConstant(d, "HAVE_HASH_QUOTING",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "SUN_CC_4_0_SOTYPE_INIT_BUG",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "SoDebugError_ERROR",SWIG_From_int(static_cast< int >(SoDebugError::ERROR)));
  SWIG_Python_SetConstant(d, "SoDebugError_WARNING",SWIG_From_int(static_cast< int >(SoDebugError::WARNING)));
  SWIG_Python_SetConstant(d, "SoDebugError_INFO",SWIG_From_int(static_cast< int >(SoDebugError::INFO)));
  SWIG_Python_SetConstant(d, "SoNotRec_CONTAINER",SWIG_From_int(static_cast< int >(SoNotRec::CONTAINER)));
  SWIG_Python_SetConstant(d, "SoNotRec_PARENT",SWIG_From_int(static_cast< int >(SoNotRec::PARENT)));
  SWIG_Python_SetConstant(d, "SoNotRec_SENSOR",SWIG_From_int(static_cast< int >(SoNotRec::SENSOR)));
  SWIG_Python_SetConstant(d, "SoNotRec_FIELD",SWIG_From_int(static_cast< int >(SoNotRec::FIELD)));
  SWIG_Python_SetConstant(d, "SoNotRec_ENGINE",SWIG_From_int(static_cast< int >(SoNotRec::ENGINE)));
  SWIG_Python_SetConstant(d, "SoNotRec_UNSPECIFIED",SWIG_From_int(static_cast< int >(SoNotRec::UNSPECIFIED)));
  SWIG_Python_SetConstant(d, "SoNotRec_FIELD_UPDATE",SWIG_From_int(static_cast< int >(SoNotRec::FIELD_UPDATE)));
  SWIG_Python_SetConstant(d, "SoNotRec_GROUP_ADDCHILD",SWIG_From_int(static_cast< int >(SoNotRec::GROUP_ADDCHILD)));
  SWIG_Python_SetConstant(d, "SoNotRec_GROUP_INSERTCHILD",SWIG_From_int(static_cast< int >(SoNotRec::GROUP_INSERTCHILD)));
  SWIG_Python_SetConstant(d, "SoNotRec_GROUP_REPLACECHILD",SWIG_From_int(static_cast< int >(SoNotRec::GROUP_REPLACECHILD)));
  SWIG_Python_SetConstant(d, "SoNotRec_GROUP_REMOVECHILD",SWIG_From_int(static_cast< int >(SoNotRec::GROUP_REMOVECHILD)));
  SWIG_Python_SetConstant(d, "SoNotRec_GROUP_REMOVEALLCHILDREN",SWIG_From_int(static_cast< int >(SoNotRec::GROUP_REMOVEALLCHILDREN)));
  SWIG_Python_SetConstant(d, "SoField_NORMAL_FIELD",SWIG_From_int(static_cast< int >(SoField::NORMAL_FIELD)));
  SWIG_Python_SetConstant(d, "SoField_EVENTIN_FIELD",SWIG_From_int(static_cast< int >(SoField::EVENTIN_FIELD)));
  SWIG_Python_SetConstant(d, "SoField_EVENTOUT_FIELD",SWIG_From_int(static_cast< int >(SoField::EVENTOUT_FIELD)));
  SWIG_Python_SetConstant(d, "SoField_EXPOSED_FIELD",SWIG_From_int(static_cast< int >(SoField::EXPOSED_FIELD)));
  SWIG_Python_SetConstant(d, "SoAction_NODE",SWIG_From_int(static_cast< int >(SoAction::NODE)));
  SWIG_Python_SetConstant(d, "SoAction_PATH",SWIG_From_int(static_cast< int >(SoAction::PATH)));
  SWIG_Python_SetConstant(d, "SoAction_PATH_LIST",SWIG_From_int(static_cast< int >(SoAction::PATH_LIST)));
  SWIG_Python_SetConstant(d, "SoAction_NO_PATH",SWIG_From_int(static_cast< int >(SoAction::NO_PATH)));
  SWIG_Python_SetConstant(d, "SoAction_IN_PATH",SWIG_From_int(static_cast< int >(SoAction::IN_PATH)));
  SWIG_Python_SetConstant(d, "SoAction_BELOW_PATH",SWIG_From_int(static_cast< int >(SoAction::BELOW_PATH)));
  SWIG_Python_SetConstant(d, "SoAction_OFF_PATH",SWIG_From_int(static_cast< int >(SoAction::OFF_PATH)));
  SWIG_Python_SetConstant(d, "SoDecimationTypeElement_AUTOMATIC",SWIG_From_int(static_cast< int >(SoDecimationTypeElement::AUTOMATIC)));
  SWIG_Python_SetConstant(d, "SoDecimationTypeElement_HIGHEST",SWIG_From_int(static_cast< int >(SoDecimationTypeElement::HIGHEST)));
  SWIG_Python_SetConstant(d, "SoDecimationTypeElement_LOWEST",SWIG_From_int(static_cast< int >(SoDecimationTypeElement::LOWEST)));
  SWIG_Python_SetConstant(d, "SoDecimationTypeElement_PERCENTAGE",SWIG_From_int(static_cast< int >(SoDecimationTypeElement::PERCENTAGE)));
  SWIG_Python_SetConstant(d, "SoNode_FIRST_INSTANCE",SWIG_From_int(static_cast< int >(SoNode::FIRST_INSTANCE)));
  SWIG_Python_SetConstant(d, "SoNode_PROTO_INSTANCE",SWIG_From_int(static_cast< int >(SoNode::PROTO_INSTANCE)));
  SWIG_Python_SetConstant(d, "SoNode_OTHER_INSTANCE",SWIG_From_int(static_cast< int >(SoNode::OTHER_INSTANCE)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR",SWIG_From_int(static_cast< int >(SoNode::INVENTOR)));
  SWIG_Python_SetConstant(d, "SoNode_VRML1",SWIG_From_int(static_cast< int >(SoNode::VRML1)));
  SWIG_Python_SetConstant(d, "SoNode_VRML2",SWIG_From_int(static_cast< int >(SoNode::VRML2)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_1",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_1)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_2_0",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_2_0)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_2_1",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_2_1)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_2_5",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_2_5)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_2_6",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_2_6)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_1_0",SWIG_From_int(static_cast< int >(SoNode::COIN_1_0)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_2_0",SWIG_From_int(static_cast< int >(SoNode::COIN_2_0)));
  SWIG_Python_SetConstant(d, "SoNode_EXTENSION",SWIG_From_int(static_cast< int >(SoNode::EXTENSION)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_2_2",SWIG_From_int(static_cast< int >(SoNode::COIN_2_2)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_2_3",SWIG_From_int(static_cast< int >(SoNode::COIN_2_3)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_2_4",SWIG_From_int(static_cast< int >(SoNode::COIN_2_4)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_5_0",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_5_0)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_2_5",SWIG_From_int(static_cast< int >(SoNode::COIN_2_5)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_3_0",SWIG_From_int(static_cast< int >(SoNode::COIN_3_0)));
  SWIG_Python_SetConstant(d, "SoNode_INVENTOR_6_0",SWIG_From_int(static_cast< int >(SoNode::INVENTOR_6_0)));
  SWIG_Python_SetConstant(d, "SoNode_COIN_4_0",SWIG_From_int(static_cast< int >(SoNode::COIN_4_0)));
  SWIG_Python_SetConstant(d, "SoOutput_COUNT_REFS",SWIG_From_int(static_cast< int >(SoOutput::COUNT_REFS)));
  SWIG_Python_SetConstant(d, "SoOutput_WRITE",SWIG_From_int(static_cast< int >(SoOutput::WRITE)));
  SWIG_Python_SetConstant(d, "SoOutput_ADDRESSES",SWIG_From_int(static_cast< int >(SoOutput::ADDRESSES)));
  SWIG_Python_SetConstant(d, "SoOutput_REF_COUNTS",SWIG_From_int(static_cast< int >(SoOutput::REF_COUNTS)));
  SWIG_Python_SetConstant(d, "SoComplexityTypeElement_OBJECT_SPACE",SWIG_From_int(static_cast< int >(SoComplexityTypeElement::OBJECT_SPACE)));
  SWIG_Python_SetConstant(d, "SoComplexityTypeElement_SCREEN_SPACE",SWIG_From_int(static_cast< int >(SoComplexityTypeElement::SCREEN_SPACE)));
  SWIG_Python_SetConstant(d, "SoComplexityTypeElement_BOUNDING_BOX",SWIG_From_int(static_cast< int >(SoComplexityTypeElement::BOUNDING_BOX)));
  SWIG_Python_SetConstant(d, "SoComplexity_OBJECT_SPACE",SWIG_From_int(static_cast< int >(SoComplexity::OBJECT_SPACE)));
  SWIG_Python_SetConstant(d, "SoComplexity_SCREEN_SPACE",SWIG_From_int(static_cast< int >(SoComplexity::SCREEN_SPACE)));
  SWIG_Python_SetConstant(d, "SoComplexity_BOUNDING_BOX",SWIG_From_int(static_cast< int >(SoComplexity::BOUNDING_BOX)));
  SWIG_Python_SetConstant(d, "SoDrawStyleElement_FILLED",SWIG_From_int(static_cast< int >(SoDrawStyleElement::FILLED)));
  SWIG_Python_SetConstant(d, "SoDrawStyleElement_LINES",SWIG_From_int(static_cast< int >(SoDrawStyleElement::LINES)));
  SWIG_Python_SetConstant(d, "SoDrawStyleElement_POINTS",SWIG_From_int(static_cast< int >(SoDrawStyleElement::POINTS)));
  SWIG_Python_SetConstant(d, "SoDrawStyleElement_INVISIBLE",SWIG_From_int(static_cast< int >(SoDrawStyleElement::INVISIBLE)));
  SWIG_Python_SetConstant(d, "SoDrawStyle_FILLED",SWIG_From_int(static_cast< int >(SoDrawStyle::FILLED)));
  SWIG_Python_SetConstant(d, "SoDrawStyle_LINES",SWIG_From_int(static_cast< int >(SoDrawStyle::LINES)));
  SWIG_Python_SetConstant(d, "SoDrawStyle_POINTS",SWIG_From_int(static_cast< int >(SoDrawStyle::POINTS)));
  SWIG_Python_SetConstant(d, "SoDrawStyle_INVISIBLE",SWIG_From_int(static_cast< int >(SoDrawStyle::INVISIBLE)));
  SWIG_Python_SetConstant(d, "SO_LAZY_SHINY_THRESHOLD",SWIG_From_float(static_cast< float >(0.005f)));
  SWIG_Python_SetConstant(d, "SoLazyElement_LIGHT_MODEL_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::LIGHT_MODEL_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_COLOR_MATERIAL_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::COLOR_MATERIAL_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_DIFFUSE_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::DIFFUSE_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_AMBIENT_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::AMBIENT_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_EMISSIVE_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::EMISSIVE_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SPECULAR_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::SPECULAR_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SHININESS_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::SHININESS_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_BLENDING_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::BLENDING_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_TRANSPARENCY_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::TRANSPARENCY_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_VERTEXORDERING_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::VERTEXORDERING_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_TWOSIDE_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::TWOSIDE_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_CULLING_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::CULLING_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SHADE_MODEL_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::SHADE_MODEL_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_ALPHATEST_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::ALPHATEST_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_GLIMAGE_CASE",SWIG_From_int(static_cast< int >(SoLazyElement::GLIMAGE_CASE)));
  SWIG_Python_SetConstant(d, "SoLazyElement_LAZYCASES_LAST",SWIG_From_int(static_cast< int >(SoLazyElement::LAZYCASES_LAST)));
  SWIG_Python_SetConstant(d, "SoLazyElement_LIGHT_MODEL_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::LIGHT_MODEL_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_COLOR_MATERIAL_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::COLOR_MATERIAL_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_DIFFUSE_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::DIFFUSE_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_AMBIENT_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::AMBIENT_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_EMISSIVE_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::EMISSIVE_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SPECULAR_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::SPECULAR_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SHININESS_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::SHININESS_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_TRANSPARENCY_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::TRANSPARENCY_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_BLENDING_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::BLENDING_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_VERTEXORDERING_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::VERTEXORDERING_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_TWOSIDE_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::TWOSIDE_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_CULLING_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::CULLING_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_SHADE_MODEL_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::SHADE_MODEL_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_ALPHATEST_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::ALPHATEST_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_GLIMAGE_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::GLIMAGE_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_ALL_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::ALL_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_OTHER_COLOR_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::OTHER_COLOR_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_ALL_COLOR_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::ALL_COLOR_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_NO_COLOR_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::NO_COLOR_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_ALL_BUT_DIFFUSE_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::ALL_BUT_DIFFUSE_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_DIFFUSE_ONLY_MASK",SWIG_From_int(static_cast< int >(SoLazyElement::DIFFUSE_ONLY_MASK)));
  SWIG_Python_SetConstant(d, "SoLazyElement_BASE_COLOR",SWIG_From_int(static_cast< int >(SoLazyElement::BASE_COLOR)));
  SWIG_Python_SetConstant(d, "SoLazyElement_PHONG",SWIG_From_int(static_cast< int >(SoLazyElement::PHONG)));
  SWIG_Python_SetConstant(d, "SoLazyElement_CW",SWIG_From_int(static_cast< int >(SoLazyElement::CW)));
  SWIG_Python_SetConstant(d, "SoLazyElement_CCW",SWIG_From_int(static_cast< int >(SoLazyElement::CCW)));
  SWIG_Python_SetConstant(d, "SoLightModel_BASE_COLOR",SWIG_From_int(static_cast< int >(SoLightModel::BASE_COLOR)));
  SWIG_Python_SetConstant(d, "SoLightModel_PHONG",SWIG_From_int(static_cast< int >(SoLightModel::PHONG)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_OVERALL",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::OVERALL)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_PART",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_PART)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_FACE",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_VERTEX",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_DEFAULT",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoMaterialBindingElement_NONE",SWIG_From_int(static_cast< int >(SoMaterialBindingElement::NONE)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_OVERALL",SWIG_From_int(static_cast< int >(SoMaterialBinding::OVERALL)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_PART",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_PART)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_FACE",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_VERTEX",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoMaterialBinding::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_DEFAULT",SWIG_From_int(static_cast< int >(SoMaterialBinding::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoMaterialBinding_NONE",SWIG_From_int(static_cast< int >(SoMaterialBinding::NONE)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_OVERALL",SWIG_From_int(static_cast< int >(SoNormalBindingElement::OVERALL)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_PART",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_PART)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_FACE",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_VERTEX",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBindingElement::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_DEFAULT",SWIG_From_int(static_cast< int >(SoNormalBindingElement::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoNormalBindingElement_NONE",SWIG_From_int(static_cast< int >(SoNormalBindingElement::NONE)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_OVERALL",SWIG_From_int(static_cast< int >(SoNormalBinding::OVERALL)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_PART",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_PART)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_FACE",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_VERTEX",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoNormalBinding::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_DEFAULT",SWIG_From_int(static_cast< int >(SoNormalBinding::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoNormalBinding_NONE",SWIG_From_int(static_cast< int >(SoNormalBinding::NONE)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_SHAPE",SWIG_From_int(static_cast< int >(SoPickStyleElement::SHAPE)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_BOUNDING_BOX",SWIG_From_int(static_cast< int >(SoPickStyleElement::BOUNDING_BOX)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_UNPICKABLE",SWIG_From_int(static_cast< int >(SoPickStyleElement::UNPICKABLE)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_SHAPE_ON_TOP",SWIG_From_int(static_cast< int >(SoPickStyleElement::SHAPE_ON_TOP)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_BOUNDING_BOX_ON_TOP",SWIG_From_int(static_cast< int >(SoPickStyleElement::BOUNDING_BOX_ON_TOP)));
  SWIG_Python_SetConstant(d, "SoPickStyleElement_SHAPE_FRONTFACES",SWIG_From_int(static_cast< int >(SoPickStyleElement::SHAPE_FRONTFACES)));
  SWIG_Python_SetConstant(d, "SoPickStyle_SHAPE",SWIG_From_int(static_cast< int >(SoPickStyle::SHAPE)));
  SWIG_Python_SetConstant(d, "SoPickStyle_BOUNDING_BOX",SWIG_From_int(static_cast< int >(SoPickStyle::BOUNDING_BOX)));
  SWIG_Python_SetConstant(d, "SoPickStyle_UNPICKABLE",SWIG_From_int(static_cast< int >(SoPickStyle::UNPICKABLE)));
  SWIG_Python_SetConstant(d, "SoPickStyle_SHAPE_ON_TOP",SWIG_From_int(static_cast< int >(SoPickStyle::SHAPE_ON_TOP)));
  SWIG_Python_SetConstant(d, "SoPickStyle_BOUNDING_BOX_ON_TOP",SWIG_From_int(static_cast< int >(SoPickStyle::BOUNDING_BOX_ON_TOP)));
  SWIG_Python_SetConstant(d, "SoPickStyle_SHAPE_FRONTFACES",SWIG_From_int(static_cast< int >(SoPickStyle::SHAPE_FRONTFACES)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_UNKNOWN_ORDERING",SWIG_From_int(static_cast< int >(SoShapeHintsElement::UNKNOWN_ORDERING)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_CLOCKWISE",SWIG_From_int(static_cast< int >(SoShapeHintsElement::CLOCKWISE)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_COUNTERCLOCKWISE",SWIG_From_int(static_cast< int >(SoShapeHintsElement::COUNTERCLOCKWISE)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_ORDERING_AS_IS",SWIG_From_int(static_cast< int >(SoShapeHintsElement::ORDERING_AS_IS)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_UNKNOWN_SHAPE_TYPE",SWIG_From_int(static_cast< int >(SoShapeHintsElement::UNKNOWN_SHAPE_TYPE)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_SOLID",SWIG_From_int(static_cast< int >(SoShapeHintsElement::SOLID)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_SHAPE_TYPE_AS_IS",SWIG_From_int(static_cast< int >(SoShapeHintsElement::SHAPE_TYPE_AS_IS)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_UNKNOWN_FACE_TYPE",SWIG_From_int(static_cast< int >(SoShapeHintsElement::UNKNOWN_FACE_TYPE)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_CONVEX",SWIG_From_int(static_cast< int >(SoShapeHintsElement::CONVEX)));
  SWIG_Python_SetConstant(d, "SoShapeHintsElement_FACE_TYPE_AS_IS",SWIG_From_int(static_cast< int >(SoShapeHintsElement::FACE_TYPE_AS_IS)));
  SWIG_Python_SetConstant(d, "SoShapeHints_UNKNOWN_ORDERING",SWIG_From_int(static_cast< int >(SoShapeHints::UNKNOWN_ORDERING)));
  SWIG_Python_SetConstant(d, "SoShapeHints_CLOCKWISE",SWIG_From_int(static_cast< int >(SoShapeHints::CLOCKWISE)));
  SWIG_Python_SetConstant(d, "SoShapeHints_COUNTERCLOCKWISE",SWIG_From_int(static_cast< int >(SoShapeHints::COUNTERCLOCKWISE)));
  SWIG_Python_SetConstant(d, "SoShapeHints_UNKNOWN_SHAPE_TYPE",SWIG_From_int(static_cast< int >(SoShapeHints::UNKNOWN_SHAPE_TYPE)));
  SWIG_Python_SetConstant(d, "SoShapeHints_SOLID",SWIG_From_int(static_cast< int >(SoShapeHints::SOLID)));
  SWIG_Python_SetConstant(d, "SoShapeHints_UNKNOWN_FACE_TYPE",SWIG_From_int(static_cast< int >(SoShapeHints::UNKNOWN_FACE_TYPE)));
  SWIG_Python_SetConstant(d, "SoShapeHints_CONVEX",SWIG_From_int(static_cast< int >(SoShapeHints::CONVEX)));
  SWIG_Python_SetConstant(d, "SoShapeHints_NO_WINDING_TYPE",SWIG_From_int(static_cast< int >(SoShapeHints::NO_WINDING_TYPE)));
  SWIG_Python_SetConstant(d, "SoSFImage_COPY",SWIG_From_int(static_cast< int >(SoSFImage::COPY)));
  SWIG_Python_SetConstant(d, "SoSFImage_NO_COPY",SWIG_From_int(static_cast< int >(SoSFImage::NO_COPY)));
  SWIG_Python_SetConstant(d, "SoSFImage_NO_COPY_AND_DELETE",SWIG_From_int(static_cast< int >(SoSFImage::NO_COPY_AND_DELETE)));
  SWIG_Python_SetConstant(d, "SoSFImage_NO_COPY_AND_FREE",SWIG_From_int(static_cast< int >(SoSFImage::NO_COPY_AND_FREE)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_BLEND",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::BLEND)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_MODULATE",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::MODULATE)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_DECAL",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::DECAL)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_REPLACE",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::REPLACE)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_CLAMP",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::CLAMP)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_REPEAT",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::REPEAT)));
  SWIG_Python_SetConstant(d, "SoMultiTextureImageElement_CLAMP_TO_BORDER",SWIG_From_int(static_cast< int >(SoMultiTextureImageElement::CLAMP_TO_BORDER)));
  SWIG_Python_SetConstant(d, "SoTexture2_MODULATE",SWIG_From_int(static_cast< int >(SoTexture2::MODULATE)));
  SWIG_Python_SetConstant(d, "SoTexture2_DECAL",SWIG_From_int(static_cast< int >(SoTexture2::DECAL)));
  SWIG_Python_SetConstant(d, "SoTexture2_BLEND",SWIG_From_int(static_cast< int >(SoTexture2::BLEND)));
  SWIG_Python_SetConstant(d, "SoTexture2_REPLACE",SWIG_From_int(static_cast< int >(SoTexture2::REPLACE)));
  SWIG_Python_SetConstant(d, "SoTexture2_REPEAT",SWIG_From_int(static_cast< int >(SoTexture2::REPEAT)));
  SWIG_Python_SetConstant(d, "SoTexture2_CLAMP",SWIG_From_int(static_cast< int >(SoTexture2::CLAMP)));
  SWIG_Python_SetConstant(d, "SoTextureCoordinateBindingElement_PER_VERTEX",SWIG_From_int(static_cast< int >(SoTextureCoordinateBindingElement::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoTextureCoordinateBindingElement_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoTextureCoordinateBindingElement::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoTextureCoordinateBinding_PER_VERTEX",SWIG_From_int(static_cast< int >(SoTextureCoordinateBinding::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoTextureCoordinateBinding_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoTextureCoordinateBinding::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoTextureCoordinateBinding_DEFAULT",SWIG_From_int(static_cast< int >(SoTextureCoordinateBinding::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoUnits_METERS",SWIG_From_int(static_cast< int >(SoUnits::METERS)));
  SWIG_Python_SetConstant(d, "SoUnits_CENTIMETERS",SWIG_From_int(static_cast< int >(SoUnits::CENTIMETERS)));
  SWIG_Python_SetConstant(d, "SoUnits_MILLIMETERS",SWIG_From_int(static_cast< int >(SoUnits::MILLIMETERS)));
  SWIG_Python_SetConstant(d, "SoUnits_MICROMETERS",SWIG_From_int(static_cast< int >(SoUnits::MICROMETERS)));
  SWIG_Python_SetConstant(d, "SoUnits_MICRONS",SWIG_From_int(static_cast< int >(SoUnits::MICRONS)));
  SWIG_Python_SetConstant(d, "SoUnits_NANOMETERS",SWIG_From_int(static_cast< int >(SoUnits::NANOMETERS)));
  SWIG_Python_SetConstant(d, "SoUnits_ANGSTROMS",SWIG_From_int(static_cast< int >(SoUnits::ANGSTROMS)));
  SWIG_Python_SetConstant(d, "SoUnits_KILOMETERS",SWIG_From_int(static_cast< int >(SoUnits::KILOMETERS)));
  SWIG_Python_SetConstant(d, "SoUnits_FEET",SWIG_From_int(static_cast< int >(SoUnits::FEET)));
  SWIG_Python_SetConstant(d, "SoUnits_INCHES",SWIG_From_int(static_cast< int >(SoUnits::INCHES)));
  SWIG_Python_SetConstant(d, "SoUnits_POINTS",SWIG_From_int(static_cast< int >(SoUnits::POINTS)));
  SWIG_Python_SetConstant(d, "SoUnits_YARDS",SWIG_From_int(static_cast< int >(SoUnits::YARDS)));
  SWIG_Python_SetConstant(d, "SoUnits_MILES",SWIG_From_int(static_cast< int >(SoUnits::MILES)));
  SWIG_Python_SetConstant(d, "SoUnits_NAUTICAL_MILES",SWIG_From_int(static_cast< int >(SoUnits::NAUTICAL_MILES)));
  SWIG_Python_SetConstant(d, "SoCallbackAction_CONTINUE",SWIG_From_int(static_cast< int >(SoCallbackAction::CONTINUE)));
  SWIG_Python_SetConstant(d, "SoCallbackAction_ABORT",SWIG_From_int(static_cast< int >(SoCallbackAction::ABORT)));
  SWIG_Python_SetConstant(d, "SoCallbackAction_PRUNE",SWIG_From_int(static_cast< int >(SoCallbackAction::PRUNE)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SCREEN_DOOR",SWIG_From_int(static_cast< int >(SoGLRenderAction::SCREEN_DOOR)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_ADD",SWIG_From_int(static_cast< int >(SoGLRenderAction::ADD)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_DELAYED_ADD",SWIG_From_int(static_cast< int >(SoGLRenderAction::DELAYED_ADD)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SORTED_OBJECT_ADD",SWIG_From_int(static_cast< int >(SoGLRenderAction::SORTED_OBJECT_ADD)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_BLEND",SWIG_From_int(static_cast< int >(SoGLRenderAction::BLEND)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_DELAYED_BLEND",SWIG_From_int(static_cast< int >(SoGLRenderAction::DELAYED_BLEND)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SORTED_OBJECT_BLEND",SWIG_From_int(static_cast< int >(SoGLRenderAction::SORTED_OBJECT_BLEND)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_ADD",SWIG_From_int(static_cast< int >(SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_ADD)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_BLEND",SWIG_From_int(static_cast< int >(SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_NONE",SWIG_From_int(static_cast< int >(SoGLRenderAction::NONE)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_SORTED_LAYERS_BLEND",SWIG_From_int(static_cast< int >(SoGLRenderAction::SORTED_LAYERS_BLEND)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_ONE_PASS",SWIG_From_int(static_cast< int >(SoGLRenderAction::ONE_PASS)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_NONSOLID_SEPARATE_BACKFACE_PASS",SWIG_From_int(static_cast< int >(SoGLRenderAction::NONSOLID_SEPARATE_BACKFACE_PASS)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_CONTINUE",SWIG_From_int(static_cast< int >(SoGLRenderAction::CONTINUE)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_ABORT",SWIG_From_int(static_cast< int >(SoGLRenderAction::ABORT)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_PRUNE",SWIG_From_int(static_cast< int >(SoGLRenderAction::PRUNE)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_DELAY",SWIG_From_int(static_cast< int >(SoGLRenderAction::DELAY)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_BBOX_CENTER",SWIG_From_int(static_cast< int >(SoGLRenderAction::BBOX_CENTER)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_BBOX_CLOSEST_CORNER",SWIG_From_int(static_cast< int >(SoGLRenderAction::BBOX_CLOSEST_CORNER)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_BBOX_FARTHEST_CORNER",SWIG_From_int(static_cast< int >(SoGLRenderAction::BBOX_FARTHEST_CORNER)));
  SWIG_Python_SetConstant(d, "SoGLRenderAction_CUSTOM_CALLBACK",SWIG_From_int(static_cast< int >(SoGLRenderAction::CUSTOM_CALLBACK)));
  SWIG_Python_SetConstant(d, "SoGetBoundingBoxAction_TRANSFORM",SWIG_From_int(static_cast< int >(SoGetBoundingBoxAction::TRANSFORM)));
  SWIG_Python_SetConstant(d, "SoGetBoundingBoxAction_BBOX",SWIG_From_int(static_cast< int >(SoGetBoundingBoxAction::BBOX)));
  SWIG_Python_SetConstant(d, "SoGetBoundingBoxAction_ALL",SWIG_From_int(static_cast< int >(SoGetBoundingBoxAction::ALL)));
  SWIG_Python_SetConstant(d, "SoSearchAction_NODE",SWIG_From_int(static_cast< int >(SoSearchAction::NODE)));
  SWIG_Python_SetConstant(d, "SoSearchAction_TYPE",SWIG_From_int(static_cast< int >(SoSearchAction::TYPE)));
  SWIG_Python_SetConstant(d, "SoSearchAction_NAME",SWIG_From_int(static_cast< int >(SoSearchAction::NAME)));
  SWIG_Python_SetConstant(d, "SoSearchAction_FIRST",SWIG_From_int(static_cast< int >(SoSearchAction::FIRST)));
  SWIG_Python_SetConstant(d, "SoSearchAction_LAST",SWIG_From_int(static_cast< int >(SoSearchAction::LAST)));
  SWIG_Python_SetConstant(d, "SoSearchAction_ALL",SWIG_From_int(static_cast< int >(SoSearchAction::ALL)));
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
    return -1;
  }
  PyDict_SetItemString(md, "cvar", globals);
  SWIG_Python_SetConstant(d, "SoIntersectingPrimitive_SEGMENT",SWIG_From_int(static_cast< int >(SoIntersectingPrimitive::SEGMENT)));
  SWIG_Python_SetConstant(d, "SoIntersectingPrimitive_LINE_SEGMENT",SWIG_From_int(static_cast< int >(SoIntersectingPrimitive::LINE_SEGMENT)));
  SWIG_Python_SetConstant(d, "SoIntersectingPrimitive_TRIANGLE",SWIG_From_int(static_cast< int >(SoIntersectingPrimitive::TRIANGLE)));
  SWIG_Python_SetConstant(d, "SoIntersectionDetectionAction_NEXT_PRIMITIVE",SWIG_From_int(static_cast< int >(SoIntersectionDetectionAction::NEXT_PRIMITIVE)));
  SWIG_Python_SetConstant(d, "SoIntersectionDetectionAction_NEXT_SHAPE",SWIG_From_int(static_cast< int >(SoIntersectionDetectionAction::NEXT_SHAPE)));
  SWIG_Python_SetConstant(d, "SoIntersectionDetectionAction_ABORT",SWIG_From_int(static_cast< int >(SoIntersectionDetectionAction::ABORT)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_INCH",SWIG_From_int(static_cast< int >(SoVectorizeAction::INCH)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_MM",SWIG_From_int(static_cast< int >(SoVectorizeAction::MM)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_METER",SWIG_From_int(static_cast< int >(SoVectorizeAction::METER)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_PORTRAIT",SWIG_From_int(static_cast< int >(SoVectorizeAction::PORTRAIT)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_LANDSCAPE",SWIG_From_int(static_cast< int >(SoVectorizeAction::LANDSCAPE)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A0",SWIG_From_int(static_cast< int >(SoVectorizeAction::A0)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A1",SWIG_From_int(static_cast< int >(SoVectorizeAction::A1)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A2",SWIG_From_int(static_cast< int >(SoVectorizeAction::A2)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A3",SWIG_From_int(static_cast< int >(SoVectorizeAction::A3)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A4",SWIG_From_int(static_cast< int >(SoVectorizeAction::A4)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A5",SWIG_From_int(static_cast< int >(SoVectorizeAction::A5)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A6",SWIG_From_int(static_cast< int >(SoVectorizeAction::A6)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A7",SWIG_From_int(static_cast< int >(SoVectorizeAction::A7)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A8",SWIG_From_int(static_cast< int >(SoVectorizeAction::A8)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A9",SWIG_From_int(static_cast< int >(SoVectorizeAction::A9)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_A10",SWIG_From_int(static_cast< int >(SoVectorizeAction::A10)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_CIRCLE",SWIG_From_int(static_cast< int >(SoVectorizeAction::CIRCLE)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_SQUARE",SWIG_From_int(static_cast< int >(SoVectorizeAction::SQUARE)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_REVERSE_ONLY_BLACK_AND_WHITE",SWIG_From_int(static_cast< int >(SoVectorizeAction::REVERSE_ONLY_BLACK_AND_WHITE)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_AS_IS",SWIG_From_int(static_cast< int >(SoVectorizeAction::AS_IS)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_REVERSE",SWIG_From_int(static_cast< int >(SoVectorizeAction::REVERSE)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_NO_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::NO_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_MITERED_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::MITERED_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_MITERED_BEVELED_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::MITERED_BEVELED_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_BEVELED_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::BEVELED_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_TRIANGULAR_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::TRIANGULAR_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_ROUNDED_JOIN",SWIG_From_int(static_cast< int >(SoVectorizeAction::ROUNDED_JOIN)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_BUTT_END",SWIG_From_int(static_cast< int >(SoVectorizeAction::BUTT_END)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_SQUARE_END",SWIG_From_int(static_cast< int >(SoVectorizeAction::SQUARE_END)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_TRIANGULAR_END",SWIG_From_int(static_cast< int >(SoVectorizeAction::TRIANGULAR_END)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_ROUND_END",SWIG_From_int(static_cast< int >(SoVectorizeAction::ROUND_END)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_NO_HLHSR",SWIG_From_int(static_cast< int >(SoVectorizeAction::NO_HLHSR)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_HLHSR_SIMPLE_PAINTER",SWIG_From_int(static_cast< int >(SoVectorizeAction::HLHSR_SIMPLE_PAINTER)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_HLHSR_PAINTER",SWIG_From_int(static_cast< int >(SoVectorizeAction::HLHSR_PAINTER)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_HLHSR_PAINTER_SURFACE_REMOVAL",SWIG_From_int(static_cast< int >(SoVectorizeAction::HLHSR_PAINTER_SURFACE_REMOVAL)));
  SWIG_Python_SetConstant(d, "SoVectorizeAction_HIDDEN_LINES_REMOVAL",SWIG_From_int(static_cast< int >(SoVectorizeAction::HIDDEN_LINES_REMOVAL)));
  SWIG_Python_SetConstant(d, "SoMultiTextureCoordinateElement_NONE",SWIG_From_int(static_cast< int >(SoMultiTextureCoordinateElement::NONE)));
  SWIG_Python_SetConstant(d, "SoMultiTextureCoordinateElement_TEXGEN",SWIG_From_int(static_cast< int >(SoMultiTextureCoordinateElement::TEXGEN)));
  SWIG_Python_SetConstant(d, "SoMultiTextureCoordinateElement_EXPLICIT",SWIG_From_int(static_cast< int >(SoMultiTextureCoordinateElement::EXPLICIT)));
  SWIG_Python_SetConstant(d, "SoMultiTextureCoordinateElement_FUNCTION",SWIG_From_int(static_cast< int >(SoMultiTextureCoordinateElement::FUNCTION)));
  SWIG_Python_SetConstant(d, "SoMultiTextureCoordinateElement_DEFAULT",SWIG_From_int(static_cast< int >(SoMultiTextureCoordinateElement::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoShape_TRIANGLE_STRIP",SWIG_From_int(static_cast< int >(SoShape::TRIANGLE_STRIP)));
  SWIG_Python_SetConstant(d, "SoShape_TRIANGLE_FAN",SWIG_From_int(static_cast< int >(SoShape::TRIANGLE_FAN)));
  SWIG_Python_SetConstant(d, "SoShape_TRIANGLES",SWIG_From_int(static_cast< int >(SoShape::TRIANGLES)));
  SWIG_Python_SetConstant(d, "SoShape_POLYGON",SWIG_From_int(static_cast< int >(SoShape::POLYGON)));
  SWIG_Python_SetConstant(d, "SoShape_QUADS",SWIG_From_int(static_cast< int >(SoShape::QUADS)));
  SWIG_Python_SetConstant(d, "SoShape_QUAD_STRIP",SWIG_From_int(static_cast< int >(SoShape::QUAD_STRIP)));
  SWIG_Python_SetConstant(d, "SoShape_POINTS",SWIG_From_int(static_cast< int >(SoShape::POINTS)));
  SWIG_Python_SetConstant(d, "SoShape_LINES",SWIG_From_int(static_cast< int >(SoShape::LINES)));
  SWIG_Python_SetConstant(d, "SoShape_LINE_STRIP",SWIG_From_int(static_cast< int >(SoShape::LINE_STRIP)));
  SWIG_Python_SetConstant(d, "SoImage_BOTTOM",SWIG_From_int(static_cast< int >(SoImage::BOTTOM)));
  SWIG_Python_SetConstant(d, "SoImage_HALF",SWIG_From_int(static_cast< int >(SoImage::HALF)));
  SWIG_Python_SetConstant(d, "SoImage_TOP",SWIG_From_int(static_cast< int >(SoImage::TOP)));
  SWIG_Python_SetConstant(d, "SoImage_LEFT",SWIG_From_int(static_cast< int >(SoImage::LEFT)));
  SWIG_Python_SetConstant(d, "SoImage_CENTER",SWIG_From_int(static_cast< int >(SoImage::CENTER)));
  SWIG_Python_SetConstant(d, "SoImage_RIGHT",SWIG_From_int(static_cast< int >(SoImage::RIGHT)));
  SWIG_Python_SetConstant(d, "SoConvexDataCache_NONE",SWIG_From_int(static_cast< int >(SoConvexDataCache::NONE)));
  SWIG_Python_SetConstant(d, "SoConvexDataCache_PER_FACE",SWIG_From_int(static_cast< int >(SoConvexDataCache::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoConvexDataCache_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoConvexDataCache::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoConvexDataCache_PER_VERTEX",SWIG_From_int(static_cast< int >(SoConvexDataCache::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoConvexDataCache_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoConvexDataCache::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SO_CATALOG_NAME_NOT_FOUND",SWIG_From_int(static_cast< int >(-1)));
  SWIG_Python_SetConstant(d, "SoInteractionKit_OFF",SWIG_From_int(static_cast< int >(SoInteractionKit::OFF)));
  SWIG_Python_SetConstant(d, "SoInteractionKit_ON",SWIG_From_int(static_cast< int >(SoInteractionKit::ON)));
  SWIG_Python_SetConstant(d, "SoInteractionKit_AUTO",SWIG_From_int(static_cast< int >(SoInteractionKit::AUTO)));
  SWIG_Python_SetConstant(d, "SbDPViewVolume_ORTHOGRAPHIC",SWIG_From_int(static_cast< int >(SbDPViewVolume::ORTHOGRAPHIC)));
  SWIG_Python_SetConstant(d, "SbDPViewVolume_PERSPECTIVE",SWIG_From_int(static_cast< int >(SbDPViewVolume::PERSPECTIVE)));
  SWIG_Python_SetConstant(d, "SbViewVolume_ORTHOGRAPHIC",SWIG_From_int(static_cast< int >(SbViewVolume::ORTHOGRAPHIC)));
  SWIG_Python_SetConstant(d, "SbViewVolume_PERSPECTIVE",SWIG_From_int(static_cast< int >(SbViewVolume::PERSPECTIVE)));
  SWIG_Python_SetConstant(d, "SoDragger_FRONT",SWIG_From_int(static_cast< int >(SoDragger::FRONT)));
  SWIG_Python_SetConstant(d, "SoDragger_BACK",SWIG_From_int(static_cast< int >(SoDragger::BACK)));
  SWIG_Python_SetConstant(d, "SoDragger_USE_PICK",SWIG_From_int(static_cast< int >(SoDragger::USE_PICK)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_INACTIVE",SWIG_From_int(static_cast< int >(SoTransformerDragger::INACTIVE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_RIT_X_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::RIT_X_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_TOP_Y_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::TOP_Y_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_FNT_Z_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::FNT_Z_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_LFT_X_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::LFT_X_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_BOT_Y_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::BOT_Y_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_BAK_Z_ROTATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::BAK_Z_ROTATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_PX_PY_PZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::PX_PY_PZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_PX_PY_NZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::PX_PY_NZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_PX_NY_PZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::PX_NY_PZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_PX_NY_NZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::PX_NY_NZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_NX_PY_PZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::NX_PY_PZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_NX_PY_NZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::NX_PY_NZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_NX_NY_PZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::NX_NY_PZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_NX_NY_NZ_3D_SCALE",SWIG_From_int(static_cast< int >(SoTransformerDragger::NX_NY_NZ_3D_SCALE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_RIT_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::RIT_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_TOP_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::TOP_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_FNT_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::FNT_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_LFT_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::LFT_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_BOT_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::BOT_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoTransformerDragger_BAK_TRANSLATE",SWIG_From_int(static_cast< int >(SoTransformerDragger::BAK_TRANSLATE)));
  SWIG_Python_SetConstant(d, "SoAnnoText3FontSizeHintElement_ANNOTATION",SWIG_From_int(static_cast< int >(SoAnnoText3FontSizeHintElement::ANNOTATION)));
  SWIG_Python_SetConstant(d, "SoAnnoText3FontSizeHintElement_FIT_TEXT_VECTOR",SWIG_From_int(static_cast< int >(SoAnnoText3FontSizeHintElement::FIT_TEXT_VECTOR)));
  SWIG_Python_SetConstant(d, "SoAnnoText3RenderPrintElement_RENDER3D_PRINT_VECTOR",SWIG_From_int(static_cast< int >(SoAnnoText3RenderPrintElement::RENDER3D_PRINT_VECTOR)));
  SWIG_Python_SetConstant(d, "SoAnnoText3RenderPrintElement_RENDER3D_PRINT_RASTER",SWIG_From_int(static_cast< int >(SoAnnoText3RenderPrintElement::RENDER3D_PRINT_RASTER)));
  SWIG_Python_SetConstant(d, "SoAnnoText3RenderPrintElement_RENDER2D_PRINT_RASTER",SWIG_From_int(static_cast< int >(SoAnnoText3RenderPrintElement::RENDER2D_PRINT_RASTER)));
  SWIG_Python_SetConstant(d, "SoProfileElement_START_FIRST",SWIG_From_int(static_cast< int >(SoProfileElement::START_FIRST)));
  SWIG_Python_SetConstant(d, "SoProfileElement_START_NEW",SWIG_From_int(static_cast< int >(SoProfileElement::START_NEW)));
  SWIG_Python_SetConstant(d, "SoProfileElement_ADD_TO_CURRENT",SWIG_From_int(static_cast< int >(SoProfileElement::ADD_TO_CURRENT)));
  SWIG_Python_SetConstant(d, "SoMultiTextureEnabledElement_DISABLED",SWIG_From_int(static_cast< int >(SoMultiTextureEnabledElement::DISABLED)));
  SWIG_Python_SetConstant(d, "SoMultiTextureEnabledElement_TEXTURE2D",SWIG_From_int(static_cast< int >(SoMultiTextureEnabledElement::TEXTURE2D)));
  SWIG_Python_SetConstant(d, "SoMultiTextureEnabledElement_RECTANGLE",SWIG_From_int(static_cast< int >(SoMultiTextureEnabledElement::RECTANGLE)));
  SWIG_Python_SetConstant(d, "SoMultiTextureEnabledElement_CUBEMAP",SWIG_From_int(static_cast< int >(SoMultiTextureEnabledElement::CUBEMAP)));
  SWIG_Python_SetConstant(d, "SoMultiTextureEnabledElement_TEXTURE3D",SWIG_From_int(static_cast< int >(SoMultiTextureEnabledElement::TEXTURE3D)));
  SWIG_Python_SetConstant(d, "SoLinePatternElement_CONTINUOUS",SWIG_From_int(static_cast< int >(SoLinePatternElement::CONTINUOUS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_METERS",SWIG_From_int(static_cast< int >(SoUnitsElement::METERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_CENTIMETERS",SWIG_From_int(static_cast< int >(SoUnitsElement::CENTIMETERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_MILLIMETERS",SWIG_From_int(static_cast< int >(SoUnitsElement::MILLIMETERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_MICROMETERS",SWIG_From_int(static_cast< int >(SoUnitsElement::MICROMETERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_MICRONS",SWIG_From_int(static_cast< int >(SoUnitsElement::MICRONS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_NANOMETERS",SWIG_From_int(static_cast< int >(SoUnitsElement::NANOMETERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_ANGSTROMS",SWIG_From_int(static_cast< int >(SoUnitsElement::ANGSTROMS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_KILOMETERS",SWIG_From_int(static_cast< int >(SoUnitsElement::KILOMETERS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_FEET",SWIG_From_int(static_cast< int >(SoUnitsElement::FEET)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_INCHES",SWIG_From_int(static_cast< int >(SoUnitsElement::INCHES)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_POINTS",SWIG_From_int(static_cast< int >(SoUnitsElement::POINTS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_YARDS",SWIG_From_int(static_cast< int >(SoUnitsElement::YARDS)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_MILES",SWIG_From_int(static_cast< int >(SoUnitsElement::MILES)));
  SWIG_Python_SetConstant(d, "SoUnitsElement_NAUTICAL_MILES",SWIG_From_int(static_cast< int >(SoUnitsElement::NAUTICAL_MILES)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_AMBIENT_COLOR",SWIG_From_int(static_cast< int >(SoOverrideElement::AMBIENT_COLOR)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_COLOR_INDEX",SWIG_From_int(static_cast< int >(SoOverrideElement::COLOR_INDEX)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_COMPLEXITY",SWIG_From_int(static_cast< int >(SoOverrideElement::COMPLEXITY)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_COMPLEXITY_TYPE",SWIG_From_int(static_cast< int >(SoOverrideElement::COMPLEXITY_TYPE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_CREASE_ANGLE",SWIG_From_int(static_cast< int >(SoOverrideElement::CREASE_ANGLE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_DIFFUSE_COLOR",SWIG_From_int(static_cast< int >(SoOverrideElement::DIFFUSE_COLOR)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_DRAW_STYLE",SWIG_From_int(static_cast< int >(SoOverrideElement::DRAW_STYLE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_EMISSIVE_COLOR",SWIG_From_int(static_cast< int >(SoOverrideElement::EMISSIVE_COLOR)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_FONT_NAME",SWIG_From_int(static_cast< int >(SoOverrideElement::FONT_NAME)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_FONT_SIZE",SWIG_From_int(static_cast< int >(SoOverrideElement::FONT_SIZE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_LIGHT_MODEL",SWIG_From_int(static_cast< int >(SoOverrideElement::LIGHT_MODEL)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_LINE_PATTERN",SWIG_From_int(static_cast< int >(SoOverrideElement::LINE_PATTERN)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_LINE_WIDTH",SWIG_From_int(static_cast< int >(SoOverrideElement::LINE_WIDTH)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_MATERIAL_BINDING",SWIG_From_int(static_cast< int >(SoOverrideElement::MATERIAL_BINDING)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_POINT_SIZE",SWIG_From_int(static_cast< int >(SoOverrideElement::POINT_SIZE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_PICK_STYLE",SWIG_From_int(static_cast< int >(SoOverrideElement::PICK_STYLE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_SHAPE_HINTS",SWIG_From_int(static_cast< int >(SoOverrideElement::SHAPE_HINTS)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_SHININESS",SWIG_From_int(static_cast< int >(SoOverrideElement::SHININESS)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_SPECULAR_COLOR",SWIG_From_int(static_cast< int >(SoOverrideElement::SPECULAR_COLOR)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_POLYGON_OFFSET",SWIG_From_int(static_cast< int >(SoOverrideElement::POLYGON_OFFSET)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_TRANSPARENCY",SWIG_From_int(static_cast< int >(SoOverrideElement::TRANSPARENCY)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_TRANSPARENCY_TYPE",SWIG_From_int(static_cast< int >(SoOverrideElement::TRANSPARENCY_TYPE)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_NORMAL_VECTOR",SWIG_From_int(static_cast< int >(SoOverrideElement::NORMAL_VECTOR)));
  SWIG_Python_SetConstant(d, "SoOverrideElement_NORMAL_BINDING",SWIG_From_int(static_cast< int >(SoOverrideElement::NORMAL_BINDING)));
  SWIG_Python_SetConstant(d, "SoEnvironmentElement_NONE",SWIG_From_int(static_cast< int >(SoEnvironmentElement::NONE)));
  SWIG_Python_SetConstant(d, "SoEnvironmentElement_HAZE",SWIG_From_int(static_cast< int >(SoEnvironmentElement::HAZE)));
  SWIG_Python_SetConstant(d, "SoEnvironmentElement_FOG",SWIG_From_int(static_cast< int >(SoEnvironmentElement::FOG)));
  SWIG_Python_SetConstant(d, "SoEnvironmentElement_SMOKE",SWIG_From_int(static_cast< int >(SoEnvironmentElement::SMOKE)));
  SWIG_Python_SetConstant(d, "SoPolygonOffsetElement_FILLED",SWIG_From_int(static_cast< int >(SoPolygonOffsetElement::FILLED)));
  SWIG_Python_SetConstant(d, "SoPolygonOffsetElement_LINES",SWIG_From_int(static_cast< int >(SoPolygonOffsetElement::LINES)));
  SWIG_Python_SetConstant(d, "SoPolygonOffsetElement_POINTS",SWIG_From_int(static_cast< int >(SoPolygonOffsetElement::POINTS)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_LIGHTING",SWIG_From_int(static_cast< int >(SoShapeStyleElement::LIGHTING)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TEXENABLED",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TEXENABLED)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TEXFUNC",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TEXFUNC)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_BBOXCMPLX",SWIG_From_int(static_cast< int >(SoShapeStyleElement::BBOXCMPLX)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_INVISIBLE",SWIG_From_int(static_cast< int >(SoShapeStyleElement::INVISIBLE)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_ABORTCB",SWIG_From_int(static_cast< int >(SoShapeStyleElement::ABORTCB)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_OVERRIDE",SWIG_From_int(static_cast< int >(SoShapeStyleElement::OVERRIDE)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TEX3ENABLED",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TEX3ENABLED)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_BIGIMAGE",SWIG_From_int(static_cast< int >(SoShapeStyleElement::BIGIMAGE)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_BUMPMAP",SWIG_From_int(static_cast< int >(SoShapeStyleElement::BUMPMAP)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_VERTEXARRAY",SWIG_From_int(static_cast< int >(SoShapeStyleElement::VERTEXARRAY)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TRANSP_TEXTURE",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TRANSP_TEXTURE)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TRANSP_MATERIAL",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TRANSP_MATERIAL)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_TRANSP_SORTED_TRIANGLES",SWIG_From_int(static_cast< int >(SoShapeStyleElement::TRANSP_SORTED_TRIANGLES)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_SHADOWMAP",SWIG_From_int(static_cast< int >(SoShapeStyleElement::SHADOWMAP)));
  SWIG_Python_SetConstant(d, "SoShapeStyleElement_SHADOWS",SWIG_From_int(static_cast< int >(SoShapeStyleElement::SHADOWS)));
  SWIG_Python_SetConstant(d, "SoGLCacheContextElement_DO_AUTO_CACHE",SWIG_From_int(static_cast< int >(SoGLCacheContextElement::DO_AUTO_CACHE)));
  SWIG_Python_SetConstant(d, "SoGLCacheContextElement_DONT_AUTO_CACHE",SWIG_From_int(static_cast< int >(SoGLCacheContextElement::DONT_AUTO_CACHE)));
  SWIG_Python_SetConstant(d, "SoGLDisplayList_DISPLAY_LIST",SWIG_From_int(static_cast< int >(SoGLDisplayList::DISPLAY_LIST)));
  SWIG_Python_SetConstant(d, "SoGLDisplayList_TEXTURE_OBJECT",SWIG_From_int(static_cast< int >(SoGLDisplayList::TEXTURE_OBJECT)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_NEVER",SWIG_From_int(static_cast< int >(SoDepthBufferElement::NEVER)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_ALWAYS",SWIG_From_int(static_cast< int >(SoDepthBufferElement::ALWAYS)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_LESS",SWIG_From_int(static_cast< int >(SoDepthBufferElement::LESS)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_LEQUAL",SWIG_From_int(static_cast< int >(SoDepthBufferElement::LEQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_EQUAL",SWIG_From_int(static_cast< int >(SoDepthBufferElement::EQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_GEQUAL",SWIG_From_int(static_cast< int >(SoDepthBufferElement::GEQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_GREATER",SWIG_From_int(static_cast< int >(SoDepthBufferElement::GREATER)));
  SWIG_Python_SetConstant(d, "SoDepthBufferElement_NOTEQUAL",SWIG_From_int(static_cast< int >(SoDepthBufferElement::NOTEQUAL)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBindingElement_OVERALL",SWIG_From_int(static_cast< int >(SoVertexAttributeBindingElement::OVERALL)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBindingElement_PER_VERTEX",SWIG_From_int(static_cast< int >(SoVertexAttributeBindingElement::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBindingElement_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoVertexAttributeBindingElement::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBindingElement_DEFAULT",SWIG_From_int(static_cast< int >(SoVertexAttributeBindingElement::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoLightModelElement_BASE_COLOR",SWIG_From_int(static_cast< int >(SoLightModelElement::BASE_COLOR)));
  SWIG_Python_SetConstant(d, "SoLightModelElement_PHONG",SWIG_From_int(static_cast< int >(SoLightModelElement::PHONG)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_PRIMARY_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombineElement::PRIMARY_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_TEXTURE",SWIG_From_int(static_cast< int >(SoTextureCombineElement::TEXTURE)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_CONSTANT",SWIG_From_int(static_cast< int >(SoTextureCombineElement::CONSTANT)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_PREVIOUS",SWIG_From_int(static_cast< int >(SoTextureCombineElement::PREVIOUS)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_SRC_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombineElement::SRC_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_ONE_MINUS_SRC_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombineElement::ONE_MINUS_SRC_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_SRC_ALPHA",SWIG_From_int(static_cast< int >(SoTextureCombineElement::SRC_ALPHA)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_ONE_MINUS_SRC_ALPHA",SWIG_From_int(static_cast< int >(SoTextureCombineElement::ONE_MINUS_SRC_ALPHA)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_REPLACE",SWIG_From_int(static_cast< int >(SoTextureCombineElement::REPLACE)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_MODULATE",SWIG_From_int(static_cast< int >(SoTextureCombineElement::MODULATE)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_ADD",SWIG_From_int(static_cast< int >(SoTextureCombineElement::ADD)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_ADD_SIGNED",SWIG_From_int(static_cast< int >(SoTextureCombineElement::ADD_SIGNED)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_SUBTRACT",SWIG_From_int(static_cast< int >(SoTextureCombineElement::SUBTRACT)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_INTERPOLATE",SWIG_From_int(static_cast< int >(SoTextureCombineElement::INTERPOLATE)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_DOT3_RGB",SWIG_From_int(static_cast< int >(SoTextureCombineElement::DOT3_RGB)));
  SWIG_Python_SetConstant(d, "SoTextureCombineElement_DOT3_RGBA",SWIG_From_int(static_cast< int >(SoTextureCombineElement::DOT3_RGBA)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_CLEAR",SWIG_From_int(static_cast< int >(SoBoolOperation::CLEAR)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_SET",SWIG_From_int(static_cast< int >(SoBoolOperation::SET)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A",SWIG_From_int(static_cast< int >(SoBoolOperation::A)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_A",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_A)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_B",SWIG_From_int(static_cast< int >(SoBoolOperation::B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_B",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_OR_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_OR_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_A_OR_B",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_A_OR_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_OR_NOT_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_OR_NOT_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_A_OR_NOT_B",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_A_OR_NOT_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_AND_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_AND_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_A_AND_B",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_A_AND_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_AND_NOT_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_AND_NOT_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_NOT_A_AND_NOT_B",SWIG_From_int(static_cast< int >(SoBoolOperation::NOT_A_AND_NOT_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_EQUALS_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_EQUALS_B)));
  SWIG_Python_SetConstant(d, "SoBoolOperation_A_NOT_EQUALS_B",SWIG_From_int(static_cast< int >(SoBoolOperation::A_NOT_EQUALS_B)));
  SWIG_Python_SetConstant(d, "SoConcatenate_NUMINPUTS",SWIG_From_int(static_cast< int >(SoConcatenate::NUMINPUTS)));
  SWIG_Python_SetConstant(d, "SoOneShot_RETRIGGERABLE",SWIG_From_int(static_cast< int >(SoOneShot::RETRIGGERABLE)));
  SWIG_Python_SetConstant(d, "SoOneShot_HOLD_FINAL",SWIG_From_int(static_cast< int >(SoOneShot::HOLD_FINAL)));
  SWIG_Python_SetConstant(d, "SoHeightMapToNormalMap_INT8",SWIG_From_int(static_cast< int >(SoHeightMapToNormalMap::INT8)));
  SWIG_Python_SetConstant(d, "SoButtonEvent_UP",SWIG_From_int(static_cast< int >(SoButtonEvent::UP)));
  SWIG_Python_SetConstant(d, "SoButtonEvent_DOWN",SWIG_From_int(static_cast< int >(SoButtonEvent::DOWN)));
  SWIG_Python_SetConstant(d, "SoButtonEvent_UNKNOWN",SWIG_From_int(static_cast< int >(SoButtonEvent::UNKNOWN)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_ANY",SWIG_From_int(static_cast< int >(SoKeyboardEvent::ANY)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_UNDEFINED",SWIG_From_int(static_cast< int >(SoKeyboardEvent::UNDEFINED)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_LEFT_SHIFT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::LEFT_SHIFT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_RIGHT_SHIFT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::RIGHT_SHIFT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_LEFT_CONTROL",SWIG_From_int(static_cast< int >(SoKeyboardEvent::LEFT_CONTROL)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_RIGHT_CONTROL",SWIG_From_int(static_cast< int >(SoKeyboardEvent::RIGHT_CONTROL)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_LEFT_ALT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::LEFT_ALT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_RIGHT_ALT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::RIGHT_ALT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_0",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_0)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_1",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_1)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_2",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_2)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_3",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_3)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_4",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_4)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_5",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_5)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_6",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_6)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_7",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_7)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_8",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_8)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUMBER_9",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUMBER_9)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_A",SWIG_From_int(static_cast< int >(SoKeyboardEvent::A)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_B",SWIG_From_int(static_cast< int >(SoKeyboardEvent::B)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_C",SWIG_From_int(static_cast< int >(SoKeyboardEvent::C)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_D",SWIG_From_int(static_cast< int >(SoKeyboardEvent::D)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_E",SWIG_From_int(static_cast< int >(SoKeyboardEvent::E)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_G",SWIG_From_int(static_cast< int >(SoKeyboardEvent::G)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_H",SWIG_From_int(static_cast< int >(SoKeyboardEvent::H)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_I",SWIG_From_int(static_cast< int >(SoKeyboardEvent::I)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_J",SWIG_From_int(static_cast< int >(SoKeyboardEvent::J)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_K",SWIG_From_int(static_cast< int >(SoKeyboardEvent::K)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_L",SWIG_From_int(static_cast< int >(SoKeyboardEvent::L)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_M",SWIG_From_int(static_cast< int >(SoKeyboardEvent::M)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_N",SWIG_From_int(static_cast< int >(SoKeyboardEvent::N)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_O",SWIG_From_int(static_cast< int >(SoKeyboardEvent::O)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_P",SWIG_From_int(static_cast< int >(SoKeyboardEvent::P)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_Q",SWIG_From_int(static_cast< int >(SoKeyboardEvent::Q)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_R",SWIG_From_int(static_cast< int >(SoKeyboardEvent::R)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_S",SWIG_From_int(static_cast< int >(SoKeyboardEvent::S)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_T",SWIG_From_int(static_cast< int >(SoKeyboardEvent::T)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_U",SWIG_From_int(static_cast< int >(SoKeyboardEvent::U)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_V",SWIG_From_int(static_cast< int >(SoKeyboardEvent::V)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_W",SWIG_From_int(static_cast< int >(SoKeyboardEvent::W)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_X",SWIG_From_int(static_cast< int >(SoKeyboardEvent::X)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_Y",SWIG_From_int(static_cast< int >(SoKeyboardEvent::Y)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_Z",SWIG_From_int(static_cast< int >(SoKeyboardEvent::Z)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_HOME",SWIG_From_int(static_cast< int >(SoKeyboardEvent::HOME)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_LEFT_ARROW",SWIG_From_int(static_cast< int >(SoKeyboardEvent::LEFT_ARROW)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_UP_ARROW",SWIG_From_int(static_cast< int >(SoKeyboardEvent::UP_ARROW)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_RIGHT_ARROW",SWIG_From_int(static_cast< int >(SoKeyboardEvent::RIGHT_ARROW)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_DOWN_ARROW",SWIG_From_int(static_cast< int >(SoKeyboardEvent::DOWN_ARROW)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAGE_UP",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAGE_UP)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAGE_DOWN",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAGE_DOWN)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_END",SWIG_From_int(static_cast< int >(SoKeyboardEvent::END)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PRIOR",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PRIOR)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NEXT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NEXT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_ENTER",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_ENTER)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_F1",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_F1)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_F2",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_F2)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_F3",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_F3)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_F4",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_F4)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_0",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_0)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_1",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_1)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_2",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_2)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_3",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_3)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_4",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_4)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_5",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_5)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_6",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_6)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_7",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_7)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_8",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_8)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_9",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_9)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_ADD",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_ADD)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_SUBTRACT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_SUBTRACT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_MULTIPLY",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_MULTIPLY)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_DIVIDE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_DIVIDE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_SPACE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_SPACE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_TAB",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_TAB)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_INSERT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_INSERT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_DELETE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_DELETE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAD_PERIOD",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAD_PERIOD)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F1",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F1)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F2",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F2)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F3",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F3)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F4",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F4)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F5",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F5)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F6",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F6)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F7",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F7)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F8",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F8)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F9",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F9)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F10",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F10)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F11",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F11)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_F12",SWIG_From_int(static_cast< int >(SoKeyboardEvent::F12)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_BACKSPACE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::BACKSPACE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_TAB",SWIG_From_int(static_cast< int >(SoKeyboardEvent::TAB)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_RETURN",SWIG_From_int(static_cast< int >(SoKeyboardEvent::RETURN)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_ENTER",SWIG_From_int(static_cast< int >(SoKeyboardEvent::ENTER)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PAUSE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PAUSE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_SCROLL_LOCK",SWIG_From_int(static_cast< int >(SoKeyboardEvent::SCROLL_LOCK)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_ESCAPE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::ESCAPE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_DELETE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::DELETE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_KEY_DELETE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::KEY_DELETE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PRINT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PRINT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_INSERT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::INSERT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_NUM_LOCK",SWIG_From_int(static_cast< int >(SoKeyboardEvent::NUM_LOCK)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_CAPS_LOCK",SWIG_From_int(static_cast< int >(SoKeyboardEvent::CAPS_LOCK)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_SHIFT_LOCK",SWIG_From_int(static_cast< int >(SoKeyboardEvent::SHIFT_LOCK)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_SPACE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::SPACE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_APOSTROPHE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::APOSTROPHE)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_COMMA",SWIG_From_int(static_cast< int >(SoKeyboardEvent::COMMA)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_MINUS",SWIG_From_int(static_cast< int >(SoKeyboardEvent::MINUS)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_PERIOD",SWIG_From_int(static_cast< int >(SoKeyboardEvent::PERIOD)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_SLASH",SWIG_From_int(static_cast< int >(SoKeyboardEvent::SLASH)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_SEMICOLON",SWIG_From_int(static_cast< int >(SoKeyboardEvent::SEMICOLON)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_EQUAL",SWIG_From_int(static_cast< int >(SoKeyboardEvent::EQUAL)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_BRACKETLEFT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::BRACKETLEFT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_BACKSLASH",SWIG_From_int(static_cast< int >(SoKeyboardEvent::BACKSLASH)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_BRACKETRIGHT",SWIG_From_int(static_cast< int >(SoKeyboardEvent::BRACKETRIGHT)));
  SWIG_Python_SetConstant(d, "SoKeyboardEvent_GRAVE",SWIG_From_int(static_cast< int >(SoKeyboardEvent::GRAVE)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_ANY",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::ANY)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_BUTTON1",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::BUTTON1)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_BUTTON2",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::BUTTON2)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_BUTTON3",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::BUTTON3)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_BUTTON4",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::BUTTON4)));
  SWIG_Python_SetConstant(d, "SoMouseButtonEvent_BUTTON5",SWIG_From_int(static_cast< int >(SoMouseButtonEvent::BUTTON5)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_ANY",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::ANY)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON1",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON1)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON2",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON2)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON3",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON3)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON4",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON4)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON5",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON5)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON6",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON6)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON7",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON7)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_BUTTON8",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::BUTTON8)));
  SWIG_Python_SetConstant(d, "SoSpaceballButtonEvent_PICK",SWIG_From_int(static_cast< int >(SoSpaceballButtonEvent::PICK)));
  SWIG_Python_SetConstant(d, "SoGLImage_REPEAT",SWIG_From_int(static_cast< int >(SoGLImage::REPEAT)));
  SWIG_Python_SetConstant(d, "SoGLImage_CLAMP",SWIG_From_int(static_cast< int >(SoGLImage::CLAMP)));
  SWIG_Python_SetConstant(d, "SoGLImage_CLAMP_TO_EDGE",SWIG_From_int(static_cast< int >(SoGLImage::CLAMP_TO_EDGE)));
  SWIG_Python_SetConstant(d, "SoGLImage_CLAMP_TO_BORDER",SWIG_From_int(static_cast< int >(SoGLImage::CLAMP_TO_BORDER)));
  SWIG_Python_SetConstant(d, "SoGLImage_IMAGE",SWIG_From_int(static_cast< int >(SoGLImage::IMAGE)));
  SWIG_Python_SetConstant(d, "SoGLImage_SUBIMAGE",SWIG_From_int(static_cast< int >(SoGLImage::SUBIMAGE)));
  SWIG_Python_SetConstant(d, "SoGLImage_MIPMAP",SWIG_From_int(static_cast< int >(SoGLImage::MIPMAP)));
  SWIG_Python_SetConstant(d, "SoGLImage_SCALE_DOWN",SWIG_From_int(static_cast< int >(SoGLImage::SCALE_DOWN)));
  SWIG_Python_SetConstant(d, "SoGLImage_NO_MIPMAP",SWIG_From_int(static_cast< int >(SoGLImage::NO_MIPMAP)));
  SWIG_Python_SetConstant(d, "SoGLImage_LINEAR_MAG_FILTER",SWIG_From_int(static_cast< int >(SoGLImage::LINEAR_MAG_FILTER)));
  SWIG_Python_SetConstant(d, "SoGLImage_LINEAR_MIN_FILTER",SWIG_From_int(static_cast< int >(SoGLImage::LINEAR_MIN_FILTER)));
  SWIG_Python_SetConstant(d, "SoGLImage_LINEAR_MIPMAP_FILTER",SWIG_From_int(static_cast< int >(SoGLImage::LINEAR_MIPMAP_FILTER)));
  SWIG_Python_SetConstant(d, "SoGLImage_FORCE_TRANSPARENCY_TRUE",SWIG_From_int(static_cast< int >(SoGLImage::FORCE_TRANSPARENCY_TRUE)));
  SWIG_Python_SetConstant(d, "SoGLImage_FORCE_TRANSPARENCY_FALSE",SWIG_From_int(static_cast< int >(SoGLImage::FORCE_TRANSPARENCY_FALSE)));
  SWIG_Python_SetConstant(d, "SoGLImage_FORCE_ALPHA_TEST_TRUE",SWIG_From_int(static_cast< int >(SoGLImage::FORCE_ALPHA_TEST_TRUE)));
  SWIG_Python_SetConstant(d, "SoGLImage_FORCE_ALPHA_TEST_FALSE",SWIG_From_int(static_cast< int >(SoGLImage::FORCE_ALPHA_TEST_FALSE)));
  SWIG_Python_SetConstant(d, "SoGLImage_INVINCIBLE",SWIG_From_int(static_cast< int >(SoGLImage::INVINCIBLE)));
  SWIG_Python_SetConstant(d, "SoGLImage_RECTANGLE",SWIG_From_int(static_cast< int >(SoGLImage::RECTANGLE)));
  SWIG_Python_SetConstant(d, "SoGLImage_COMPRESSED",SWIG_From_int(static_cast< int >(SoGLImage::COMPRESSED)));
  SWIG_Python_SetConstant(d, "SoGLImage_USE_QUALITY_VALUE",SWIG_From_int(static_cast< int >(SoGLImage::USE_QUALITY_VALUE)));
  SWIG_Python_SetConstant(d, "SoGlyph_FONT2D",SWIG_From_int(static_cast< int >(SoGlyph::FONT2D)));
  SWIG_Python_SetConstant(d, "SoGlyph_FONT3D",SWIG_From_int(static_cast< int >(SoGlyph::FONT3D)));
  SWIG_Python_SetConstant(d, "SoSeparatorKit_OFF",SWIG_From_int(static_cast< int >(SoSeparatorKit::OFF)));
  SWIG_Python_SetConstant(d, "SoSeparatorKit_ON",SWIG_From_int(static_cast< int >(SoSeparatorKit::ON)));
  SWIG_Python_SetConstant(d, "SoSeparatorKit_AUTO",SWIG_From_int(static_cast< int >(SoSeparatorKit::AUTO)));
  SWIG_Python_SetConstant(d, "SoSeparator_OFF",SWIG_From_int(static_cast< int >(SoSeparator::OFF)));
  SWIG_Python_SetConstant(d, "SoSeparator_ON",SWIG_From_int(static_cast< int >(SoSeparator::ON)));
  SWIG_Python_SetConstant(d, "SoSeparator_AUTO",SWIG_From_int(static_cast< int >(SoSeparator::AUTO)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_X",SWIG_From_int(static_cast< int >(SoAntiSquish::X)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_Y",SWIG_From_int(static_cast< int >(SoAntiSquish::Y)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_Z",SWIG_From_int(static_cast< int >(SoAntiSquish::Z)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_AVERAGE_DIMENSION",SWIG_From_int(static_cast< int >(SoAntiSquish::AVERAGE_DIMENSION)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_BIGGEST_DIMENSION",SWIG_From_int(static_cast< int >(SoAntiSquish::BIGGEST_DIMENSION)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_SMALLEST_DIMENSION",SWIG_From_int(static_cast< int >(SoAntiSquish::SMALLEST_DIMENSION)));
  SWIG_Python_SetConstant(d, "SoAntiSquish_LONGEST_DIAGONAL",SWIG_From_int(static_cast< int >(SoAntiSquish::LONGEST_DIAGONAL)));
  SWIG_Python_SetConstant(d, "SoArray_FIRST",SWIG_From_int(static_cast< int >(SoArray::FIRST)));
  SWIG_Python_SetConstant(d, "SoArray_CENTER",SWIG_From_int(static_cast< int >(SoArray::CENTER)));
  SWIG_Python_SetConstant(d, "SoArray_LAST",SWIG_From_int(static_cast< int >(SoArray::LAST)));
  SWIG_Python_SetConstant(d, "SoAsciiText_LEFT",SWIG_From_int(static_cast< int >(SoAsciiText::LEFT)));
  SWIG_Python_SetConstant(d, "SoAsciiText_RIGHT",SWIG_From_int(static_cast< int >(SoAsciiText::RIGHT)));
  SWIG_Python_SetConstant(d, "SoAsciiText_CENTER",SWIG_From_int(static_cast< int >(SoAsciiText::CENTER)));
  SWIG_Python_SetConstant(d, "SO_SWITCH_NONE",SWIG_From_int(static_cast< int >((-1))));
  SWIG_Python_SetConstant(d, "SO_SWITCH_INHERIT",SWIG_From_int(static_cast< int >((-2))));
  SWIG_Python_SetConstant(d, "SO_SWITCH_ALL",SWIG_From_int(static_cast< int >((-3))));
  SWIG_Python_SetConstant(d, "SoBumpMap_REPEAT",SWIG_From_int(static_cast< int >(SoBumpMap::REPEAT)));
  SWIG_Python_SetConstant(d, "SoBumpMap_CLAMP",SWIG_From_int(static_cast< int >(SoBumpMap::CLAMP)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_SQUARE",SWIG_From_float(static_cast< float >(1.0f)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_VIDEO",SWIG_From_float(static_cast< float >((4.0f/3.0f))));
  SWIG_Python_SetConstant(d, "SO_ASPECT_35mm_ACADEMY",SWIG_From_double(static_cast< double >(1.371)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_16mm",SWIG_From_double(static_cast< double >(1.369)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_35mm_FULL",SWIG_From_double(static_cast< double >(1.33333)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_70mm",SWIG_From_double(static_cast< double >(2.287)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_CINEMASCOPE",SWIG_From_double(static_cast< double >(2.35)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_HDTV",SWIG_From_float(static_cast< float >((16.0f/9.0f))));
  SWIG_Python_SetConstant(d, "SO_ASPECT_PANAVISION",SWIG_From_double(static_cast< double >(2.361)));
  SWIG_Python_SetConstant(d, "SO_ASPECT_35mm",SWIG_From_float(static_cast< float >((3.0f/2.0f))));
  SWIG_Python_SetConstant(d, "SO_ASPECT_VISTAVISION",SWIG_From_double(static_cast< double >(2.301)));
  SWIG_Python_SetConstant(d, "SoCamera_CROP_VIEWPORT_FILL_FRAME",SWIG_From_int(static_cast< int >(SoCamera::CROP_VIEWPORT_FILL_FRAME)));
  SWIG_Python_SetConstant(d, "SoCamera_CROP_VIEWPORT_LINE_FRAME",SWIG_From_int(static_cast< int >(SoCamera::CROP_VIEWPORT_LINE_FRAME)));
  SWIG_Python_SetConstant(d, "SoCamera_CROP_VIEWPORT_NO_FRAME",SWIG_From_int(static_cast< int >(SoCamera::CROP_VIEWPORT_NO_FRAME)));
  SWIG_Python_SetConstant(d, "SoCamera_ADJUST_CAMERA",SWIG_From_int(static_cast< int >(SoCamera::ADJUST_CAMERA)));
  SWIG_Python_SetConstant(d, "SoCamera_LEAVE_ALONE",SWIG_From_int(static_cast< int >(SoCamera::LEAVE_ALONE)));
  SWIG_Python_SetConstant(d, "SoCamera_MONOSCOPIC",SWIG_From_int(static_cast< int >(SoCamera::MONOSCOPIC)));
  SWIG_Python_SetConstant(d, "SoCamera_LEFT_VIEW",SWIG_From_int(static_cast< int >(SoCamera::LEFT_VIEW)));
  SWIG_Python_SetConstant(d, "SoCamera_RIGHT_VIEW",SWIG_From_int(static_cast< int >(SoCamera::RIGHT_VIEW)));
  SWIG_Python_SetConstant(d, "SoCone_SIDES",SWIG_From_int(static_cast< int >(SoCone::SIDES)));
  SWIG_Python_SetConstant(d, "SoCone_BOTTOM",SWIG_From_int(static_cast< int >(SoCone::BOTTOM)));
  SWIG_Python_SetConstant(d, "SoCone_ALL",SWIG_From_int(static_cast< int >(SoCone::ALL)));
  SWIG_Python_SetConstant(d, "SoCylinder_SIDES",SWIG_From_int(static_cast< int >(SoCylinder::SIDES)));
  SWIG_Python_SetConstant(d, "SoCylinder_TOP",SWIG_From_int(static_cast< int >(SoCylinder::TOP)));
  SWIG_Python_SetConstant(d, "SoCylinder_BOTTOM",SWIG_From_int(static_cast< int >(SoCylinder::BOTTOM)));
  SWIG_Python_SetConstant(d, "SoCylinder_ALL",SWIG_From_int(static_cast< int >(SoCylinder::ALL)));
  SWIG_Python_SetConstant(d, "SoEnvironment_NONE",SWIG_From_int(static_cast< int >(SoEnvironment::NONE)));
  SWIG_Python_SetConstant(d, "SoEnvironment_HAZE",SWIG_From_int(static_cast< int >(SoEnvironment::HAZE)));
  SWIG_Python_SetConstant(d, "SoEnvironment_FOG",SWIG_From_int(static_cast< int >(SoEnvironment::FOG)));
  SWIG_Python_SetConstant(d, "SoEnvironment_SMOKE",SWIG_From_int(static_cast< int >(SoEnvironment::SMOKE)));
  SWIG_Python_SetConstant(d, "SoSelection_SINGLE",SWIG_From_int(static_cast< int >(SoSelection::SINGLE)));
  SWIG_Python_SetConstant(d, "SoSelection_TOGGLE",SWIG_From_int(static_cast< int >(SoSelection::TOGGLE)));
  SWIG_Python_SetConstant(d, "SoSelection_SHIFT",SWIG_From_int(static_cast< int >(SoSelection::SHIFT)));
  SWIG_Python_SetConstant(d, "SoSelection_DISABLE",SWIG_From_int(static_cast< int >(SoSelection::DISABLE)));
  SWIG_Python_SetConstant(d, "SoExtSelection_NOLASSO",SWIG_From_int(static_cast< int >(SoExtSelection::NOLASSO)));
  SWIG_Python_SetConstant(d, "SoExtSelection_LASSO",SWIG_From_int(static_cast< int >(SoExtSelection::LASSO)));
  SWIG_Python_SetConstant(d, "SoExtSelection_RECTANGLE",SWIG_From_int(static_cast< int >(SoExtSelection::RECTANGLE)));
  SWIG_Python_SetConstant(d, "SoExtSelection_FULL_BBOX",SWIG_From_int(static_cast< int >(SoExtSelection::FULL_BBOX)));
  SWIG_Python_SetConstant(d, "SoExtSelection_PART_BBOX",SWIG_From_int(static_cast< int >(SoExtSelection::PART_BBOX)));
  SWIG_Python_SetConstant(d, "SoExtSelection_FULL",SWIG_From_int(static_cast< int >(SoExtSelection::FULL)));
  SWIG_Python_SetConstant(d, "SoExtSelection_PART",SWIG_From_int(static_cast< int >(SoExtSelection::PART)));
  SWIG_Python_SetConstant(d, "SoExtSelection_ALL_SHAPES",SWIG_From_int(static_cast< int >(SoExtSelection::ALL_SHAPES)));
  SWIG_Python_SetConstant(d, "SoExtSelection_VISIBLE_SHAPES",SWIG_From_int(static_cast< int >(SoExtSelection::VISIBLE_SHAPES)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_OVERALL",SWIG_From_int(static_cast< int >(SoVertexProperty::OVERALL)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_PART",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_PART)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_FACE",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_VERTEX",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoVertexProperty_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoVertexProperty::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoFontStyle_SERIF",SWIG_From_int(static_cast< int >(SoFontStyle::SERIF)));
  SWIG_Python_SetConstant(d, "SoFontStyle_SANS",SWIG_From_int(static_cast< int >(SoFontStyle::SANS)));
  SWIG_Python_SetConstant(d, "SoFontStyle_TYPEWRITER",SWIG_From_int(static_cast< int >(SoFontStyle::TYPEWRITER)));
  SWIG_Python_SetConstant(d, "SoFontStyle_NONE",SWIG_From_int(static_cast< int >(SoFontStyle::NONE)));
  SWIG_Python_SetConstant(d, "SoFontStyle_BOLD",SWIG_From_int(static_cast< int >(SoFontStyle::BOLD)));
  SWIG_Python_SetConstant(d, "SoFontStyle_ITALIC",SWIG_From_int(static_cast< int >(SoFontStyle::ITALIC)));
  SWIG_Python_SetConstant(d, "SO_END_FACE_INDEX",SWIG_From_int(static_cast< int >((-1))));
  SWIG_Python_SetConstant(d, "SO_END_LINE_INDEX",SWIG_From_int(static_cast< int >((-1))));
  SWIG_Python_SetConstant(d, "SO_END_STRIP_INDEX",SWIG_From_int(static_cast< int >((-1))));
  SWIG_Python_SetConstant(d, "SoProfile_START_FIRST",SWIG_From_int(static_cast< int >(SoProfile::START_FIRST)));
  SWIG_Python_SetConstant(d, "SoProfile_START_NEW",SWIG_From_int(static_cast< int >(SoProfile::START_NEW)));
  SWIG_Python_SetConstant(d, "SoProfile_ADD_TO_CURRENT",SWIG_From_int(static_cast< int >(SoProfile::ADD_TO_CURRENT)));
  SWIG_Python_SetConstant(d, "SoLocateHighlight_AUTO",SWIG_From_int(static_cast< int >(SoLocateHighlight::AUTO)));
  SWIG_Python_SetConstant(d, "SoLocateHighlight_ON",SWIG_From_int(static_cast< int >(SoLocateHighlight::ON)));
  SWIG_Python_SetConstant(d, "SoLocateHighlight_OFF",SWIG_From_int(static_cast< int >(SoLocateHighlight::OFF)));
  SWIG_Python_SetConstant(d, "SoLocateHighlight_EMISSIVE",SWIG_From_int(static_cast< int >(SoLocateHighlight::EMISSIVE)));
  SWIG_Python_SetConstant(d, "SoLocateHighlight_EMISSIVE_DIFFUSE",SWIG_From_int(static_cast< int >(SoLocateHighlight::EMISSIVE_DIFFUSE)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_NONE",SWIG_From_int(static_cast< int >(SoMarkerSet::NONE)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CROSS_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::CROSS_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PLUS_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::PLUS_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_MINUS_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::MINUS_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SLASH_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SLASH_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BACKSLASH_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::BACKSLASH_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BAR_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::BAR_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_STAR_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::STAR_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_Y_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::Y_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_LIGHTNING_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::LIGHTNING_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_WELL_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::WELL_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_LINE_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_LINE_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_FILLED_5_5",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_FILLED_5_5)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CROSS_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::CROSS_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PLUS_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::PLUS_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_MINUS_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::MINUS_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SLASH_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SLASH_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BACKSLASH_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::BACKSLASH_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BAR_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::BAR_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_STAR_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::STAR_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_Y_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::Y_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_LIGHTNING_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::LIGHTNING_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_WELL_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::WELL_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_LINE_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_LINE_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_FILLED_7_7",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_FILLED_7_7)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CROSS_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::CROSS_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PLUS_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::PLUS_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_MINUS_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::MINUS_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SLASH_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SLASH_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BACKSLASH_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::BACKSLASH_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_BAR_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::BAR_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_STAR_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::STAR_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_Y_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::Y_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_LIGHTNING_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::LIGHTNING_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_WELL_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::WELL_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_LINE_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_LINE_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CIRCLE_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::CIRCLE_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SQUARE_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SQUARE_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_DIAMOND_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::DIAMOND_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_TRIANGLE_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::TRIANGLE_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_RHOMBUS_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::RHOMBUS_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_HOURGLASS_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::HOURGLASS_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SATELLITE_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SATELLITE_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_PINE_TREE_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::PINE_TREE_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_CAUTION_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::CAUTION_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_SHIP_FILLED_9_9",SWIG_From_int(static_cast< int >(SoMarkerSet::SHIP_FILLED_9_9)));
  SWIG_Python_SetConstant(d, "SoMarkerSet_NUM_MARKERS",SWIG_From_int(static_cast< int >(SoMarkerSet::NUM_MARKERS)));
  SWIG_Python_SetConstant(d, "SoText2_LEFT",SWIG_From_int(static_cast< int >(SoText2::LEFT)));
  SWIG_Python_SetConstant(d, "SoText2_RIGHT",SWIG_From_int(static_cast< int >(SoText2::RIGHT)));
  SWIG_Python_SetConstant(d, "SoText2_CENTER",SWIG_From_int(static_cast< int >(SoText2::CENTER)));
  SWIG_Python_SetConstant(d, "SoText3_FRONT",SWIG_From_int(static_cast< int >(SoText3::FRONT)));
  SWIG_Python_SetConstant(d, "SoText3_SIDES",SWIG_From_int(static_cast< int >(SoText3::SIDES)));
  SWIG_Python_SetConstant(d, "SoText3_BACK",SWIG_From_int(static_cast< int >(SoText3::BACK)));
  SWIG_Python_SetConstant(d, "SoText3_ALL",SWIG_From_int(static_cast< int >(SoText3::ALL)));
  SWIG_Python_SetConstant(d, "SoText3_LEFT",SWIG_From_int(static_cast< int >(SoText3::LEFT)));
  SWIG_Python_SetConstant(d, "SoText3_RIGHT",SWIG_From_int(static_cast< int >(SoText3::RIGHT)));
  SWIG_Python_SetConstant(d, "SoText3_CENTER",SWIG_From_int(static_cast< int >(SoText3::CENTER)));
  SWIG_Python_SetConstant(d, "SoWWWAnchor_NONE",SWIG_From_int(static_cast< int >(SoWWWAnchor::NONE)));
  SWIG_Python_SetConstant(d, "SoWWWAnchor_POINT",SWIG_From_int(static_cast< int >(SoWWWAnchor::POINT)));
  SWIG_Python_SetConstant(d, "SoResetTransform_TRANSFORM",SWIG_From_int(static_cast< int >(SoResetTransform::TRANSFORM)));
  SWIG_Python_SetConstant(d, "SoResetTransform_BBOX",SWIG_From_int(static_cast< int >(SoResetTransform::BBOX)));
  SWIG_Python_SetConstant(d, "SoRotationXYZ_X",SWIG_From_int(static_cast< int >(SoRotationXYZ::X)));
  SWIG_Python_SetConstant(d, "SoRotationXYZ_Y",SWIG_From_int(static_cast< int >(SoRotationXYZ::Y)));
  SWIG_Python_SetConstant(d, "SoRotationXYZ_Z",SWIG_From_int(static_cast< int >(SoRotationXYZ::Z)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBinding_OVERALL",SWIG_From_int(static_cast< int >(SoVertexAttributeBinding::OVERALL)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBinding_PER_VERTEX",SWIG_From_int(static_cast< int >(SoVertexAttributeBinding::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBinding_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoVertexAttributeBinding::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVertexAttributeBinding_DEFAULT",SWIG_From_int(static_cast< int >(SoVertexAttributeBinding::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoPolygonOffset_FILLED",SWIG_From_int(static_cast< int >(SoPolygonOffset::FILLED)));
  SWIG_Python_SetConstant(d, "SoPolygonOffset_LINES",SWIG_From_int(static_cast< int >(SoPolygonOffset::LINES)));
  SWIG_Python_SetConstant(d, "SoPolygonOffset_POINTS",SWIG_From_int(static_cast< int >(SoPolygonOffset::POINTS)));
  SWIG_Python_SetConstant(d, "SoTexture3_MODULATE",SWIG_From_int(static_cast< int >(SoTexture3::MODULATE)));
  SWIG_Python_SetConstant(d, "SoTexture3_DECAL",SWIG_From_int(static_cast< int >(SoTexture3::DECAL)));
  SWIG_Python_SetConstant(d, "SoTexture3_BLEND",SWIG_From_int(static_cast< int >(SoTexture3::BLEND)));
  SWIG_Python_SetConstant(d, "SoTexture3_REPEAT",SWIG_From_int(static_cast< int >(SoTexture3::REPEAT)));
  SWIG_Python_SetConstant(d, "SoTexture3_CLAMP",SWIG_From_int(static_cast< int >(SoTexture3::CLAMP)));
  SWIG_Python_SetConstant(d, "SoWWWInline_NEVER",SWIG_From_int(static_cast< int >(SoWWWInline::NEVER)));
  SWIG_Python_SetConstant(d, "SoWWWInline_UNTIL_LOADED",SWIG_From_int(static_cast< int >(SoWWWInline::UNTIL_LOADED)));
  SWIG_Python_SetConstant(d, "SoWWWInline_ALWAYS",SWIG_From_int(static_cast< int >(SoWWWInline::ALWAYS)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_SCREEN_DOOR",SWIG_From_int(static_cast< int >(SoTransparencyType::SCREEN_DOOR)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_ADD",SWIG_From_int(static_cast< int >(SoTransparencyType::ADD)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_DELAYED_ADD",SWIG_From_int(static_cast< int >(SoTransparencyType::DELAYED_ADD)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_SORTED_OBJECT_ADD",SWIG_From_int(static_cast< int >(SoTransparencyType::SORTED_OBJECT_ADD)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_BLEND",SWIG_From_int(static_cast< int >(SoTransparencyType::BLEND)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_DELAYED_BLEND",SWIG_From_int(static_cast< int >(SoTransparencyType::DELAYED_BLEND)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_SORTED_OBJECT_BLEND",SWIG_From_int(static_cast< int >(SoTransparencyType::SORTED_OBJECT_BLEND)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_ADD",SWIG_From_int(static_cast< int >(SoTransparencyType::SORTED_OBJECT_SORTED_TRIANGLE_ADD)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_BLEND",SWIG_From_int(static_cast< int >(SoTransparencyType::SORTED_OBJECT_SORTED_TRIANGLE_BLEND)));
  SWIG_Python_SetConstant(d, "SoTransparencyType_NONE",SWIG_From_int(static_cast< int >(SoTransparencyType::NONE)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_MODULATE",SWIG_From_int(static_cast< int >(SoTextureCubeMap::MODULATE)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_DECAL",SWIG_From_int(static_cast< int >(SoTextureCubeMap::DECAL)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_BLEND",SWIG_From_int(static_cast< int >(SoTextureCubeMap::BLEND)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_REPLACE",SWIG_From_int(static_cast< int >(SoTextureCubeMap::REPLACE)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_REPEAT",SWIG_From_int(static_cast< int >(SoTextureCubeMap::REPEAT)));
  SWIG_Python_SetConstant(d, "SoTextureCubeMap_CLAMP",SWIG_From_int(static_cast< int >(SoTextureCubeMap::CLAMP)));
  SWIG_Python_SetConstant(d, "SoShaderObject_ARB_PROGRAM",SWIG_From_int(static_cast< int >(SoShaderObject::ARB_PROGRAM)));
  SWIG_Python_SetConstant(d, "SoShaderObject_CG_PROGRAM",SWIG_From_int(static_cast< int >(SoShaderObject::CG_PROGRAM)));
  SWIG_Python_SetConstant(d, "SoShaderObject_GLSL_PROGRAM",SWIG_From_int(static_cast< int >(SoShaderObject::GLSL_PROGRAM)));
  SWIG_Python_SetConstant(d, "SoShaderObject_FILENAME",SWIG_From_int(static_cast< int >(SoShaderObject::FILENAME)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_MODELVIEW",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::MODELVIEW)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_PROJECTION",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::PROJECTION)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_TEXTURE",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::TEXTURE)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_MODELVIEW_PROJECTION",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::MODELVIEW_PROJECTION)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_IDENTITY",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::IDENTITY)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_TRANSPOSE",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::TRANSPOSE)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_INVERSE",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::INVERSE)));
  SWIG_Python_SetConstant(d, "SoShaderStateMatrixParameter_INVERSE_TRANSPOSE",SWIG_From_int(static_cast< int >(SoShaderStateMatrixParameter::INVERSE_TRANSPOSE)));
  SWIG_Python_SetConstant(d, "SoTextureScalePolicy_USE_TEXTURE_QUALITY",SWIG_From_int(static_cast< int >(SoTextureScalePolicy::USE_TEXTURE_QUALITY)));
  SWIG_Python_SetConstant(d, "SoTextureScalePolicy_SCALE_DOWN",SWIG_From_int(static_cast< int >(SoTextureScalePolicy::SCALE_DOWN)));
  SWIG_Python_SetConstant(d, "SoTextureScalePolicy_SCALE_UP",SWIG_From_int(static_cast< int >(SoTextureScalePolicy::SCALE_UP)));
  SWIG_Python_SetConstant(d, "SoTextureScalePolicy_FRACTURE",SWIG_From_int(static_cast< int >(SoTextureScalePolicy::FRACTURE)));
  SWIG_Python_SetConstant(d, "SoTextureUnit_BUMP_MAPPING",SWIG_From_int(static_cast< int >(SoTextureUnit::BUMP_MAPPING)));
  SWIG_Python_SetConstant(d, "SoTextureUnit_IMAGE_MAPPING",SWIG_From_int(static_cast< int >(SoTextureUnit::IMAGE_MAPPING)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_PRIMARY_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombine::PRIMARY_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_TEXTURE",SWIG_From_int(static_cast< int >(SoTextureCombine::TEXTURE)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_CONSTANT",SWIG_From_int(static_cast< int >(SoTextureCombine::CONSTANT)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_PREVIOUS",SWIG_From_int(static_cast< int >(SoTextureCombine::PREVIOUS)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_SRC_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombine::SRC_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_ONE_MINUS_SRC_COLOR",SWIG_From_int(static_cast< int >(SoTextureCombine::ONE_MINUS_SRC_COLOR)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_SRC_ALPHA",SWIG_From_int(static_cast< int >(SoTextureCombine::SRC_ALPHA)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_ONE_MINUS_SRC_ALPHA",SWIG_From_int(static_cast< int >(SoTextureCombine::ONE_MINUS_SRC_ALPHA)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_REPLACE",SWIG_From_int(static_cast< int >(SoTextureCombine::REPLACE)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_MODULATE",SWIG_From_int(static_cast< int >(SoTextureCombine::MODULATE)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_ADD",SWIG_From_int(static_cast< int >(SoTextureCombine::ADD)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_ADD_SIGNED",SWIG_From_int(static_cast< int >(SoTextureCombine::ADD_SIGNED)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_SUBTRACT",SWIG_From_int(static_cast< int >(SoTextureCombine::SUBTRACT)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_INTERPOLATE",SWIG_From_int(static_cast< int >(SoTextureCombine::INTERPOLATE)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_DOT3_RGB",SWIG_From_int(static_cast< int >(SoTextureCombine::DOT3_RGB)));
  SWIG_Python_SetConstant(d, "SoTextureCombine_DOT3_RGBA",SWIG_From_int(static_cast< int >(SoTextureCombine::DOT3_RGBA)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_MODULATE",SWIG_From_int(static_cast< int >(SoSceneTexture2::MODULATE)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_DECAL",SWIG_From_int(static_cast< int >(SoSceneTexture2::DECAL)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_BLEND",SWIG_From_int(static_cast< int >(SoSceneTexture2::BLEND)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_REPLACE",SWIG_From_int(static_cast< int >(SoSceneTexture2::REPLACE)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_REPEAT",SWIG_From_int(static_cast< int >(SoSceneTexture2::REPEAT)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_CLAMP",SWIG_From_int(static_cast< int >(SoSceneTexture2::CLAMP)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_CLAMP_TO_BORDER",SWIG_From_int(static_cast< int >(SoSceneTexture2::CLAMP_TO_BORDER)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_NONE",SWIG_From_int(static_cast< int >(SoSceneTexture2::NONE)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_ALPHA_BLEND",SWIG_From_int(static_cast< int >(SoSceneTexture2::ALPHA_BLEND)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_ALPHA_TEST",SWIG_From_int(static_cast< int >(SoSceneTexture2::ALPHA_TEST)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_DEPTH",SWIG_From_int(static_cast< int >(SoSceneTexture2::DEPTH)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA8",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA8)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA32F",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA32F)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB32F",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB32F)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA16F",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA16F)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB16F",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB16F)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_R3_G3_B2",SWIG_From_int(static_cast< int >(SoSceneTexture2::R3_G3_B2)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB4",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB4)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB5",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB5)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB8",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB8)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB10",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB10)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB12",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB12)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB16",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB16)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA2",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA2)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA4",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA4)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB5_A1",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB5_A1)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGB10_A2",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGB10_A2)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA12",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA12)));
  SWIG_Python_SetConstant(d, "SoSceneTexture2_RGBA16",SWIG_From_int(static_cast< int >(SoSceneTexture2::RGBA16)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_MODULATE",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::MODULATE)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_DECAL",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::DECAL)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_BLEND",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::BLEND)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_REPLACE",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::REPLACE)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_REPEAT",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::REPEAT)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_CLAMP",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::CLAMP)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_NONE",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::NONE)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_ALPHA_BLEND",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::ALPHA_BLEND)));
  SWIG_Python_SetConstant(d, "SoSceneTextureCubeMap_ALPHA_TEST",SWIG_From_int(static_cast< int >(SoSceneTextureCubeMap::ALPHA_TEST)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_NEVER",SWIG_From_int(static_cast< int >(SoDepthBuffer::NEVER)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_ALWAYS",SWIG_From_int(static_cast< int >(SoDepthBuffer::ALWAYS)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_LESS",SWIG_From_int(static_cast< int >(SoDepthBuffer::LESS)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_LEQUAL",SWIG_From_int(static_cast< int >(SoDepthBuffer::LEQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_EQUAL",SWIG_From_int(static_cast< int >(SoDepthBuffer::EQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_GEQUAL",SWIG_From_int(static_cast< int >(SoDepthBuffer::GEQUAL)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_GREATER",SWIG_From_int(static_cast< int >(SoDepthBuffer::GREATER)));
  SWIG_Python_SetConstant(d, "SoDepthBuffer_NOTEQUAL",SWIG_From_int(static_cast< int >(SoDepthBuffer::NOTEQUAL)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_NONE",SWIG_From_int(static_cast< int >(SoAlphaTest::NONE)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_NEVER",SWIG_From_int(static_cast< int >(SoAlphaTest::NEVER)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_ALWAYS",SWIG_From_int(static_cast< int >(SoAlphaTest::ALWAYS)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_LESS",SWIG_From_int(static_cast< int >(SoAlphaTest::LESS)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_LEQUAL",SWIG_From_int(static_cast< int >(SoAlphaTest::LEQUAL)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_EQUAL",SWIG_From_int(static_cast< int >(SoAlphaTest::EQUAL)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_GEQUAL",SWIG_From_int(static_cast< int >(SoAlphaTest::GEQUAL)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_GREATER",SWIG_From_int(static_cast< int >(SoAlphaTest::GREATER)));
  SWIG_Python_SetConstant(d, "SoAlphaTest_NOTEQUAL",SWIG_From_int(static_cast< int >(SoAlphaTest::NOTEQUAL)));
  SWIG_Python_SetConstant(d, "SoPathSensor_PATH",SWIG_From_int(static_cast< int >(SoPathSensor::PATH)));
  SWIG_Python_SetConstant(d, "SoPathSensor_NODES",SWIG_From_int(static_cast< int >(SoPathSensor::NODES)));
  SWIG_Python_SetConstant(d, "SoPathSensor_PATH_AND_NODES",SWIG_From_int(static_cast< int >(SoPathSensor::PATH_AND_NODES)));
  SWIG_Python_SetConstant(d, "SoOffscreenRenderer_LUMINANCE",SWIG_From_int(static_cast< int >(SoOffscreenRenderer::LUMINANCE)));
  SWIG_Python_SetConstant(d, "SoOffscreenRenderer_LUMINANCE_TRANSPARENCY",SWIG_From_int(static_cast< int >(SoOffscreenRenderer::LUMINANCE_TRANSPARENCY)));
  SWIG_Python_SetConstant(d, "SoOffscreenRenderer_RGB",SWIG_From_int(static_cast< int >(SoOffscreenRenderer::RGB)));
  SWIG_Python_SetConstant(d, "SoOffscreenRenderer_RGB_TRANSPARENCY",SWIG_From_int(static_cast< int >(SoOffscreenRenderer::RGB_TRANSPARENCY)));
  SWIG_Python_SetConstant(d, "GL_GLEXT_PROTOTYPES",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "GL_CLAMP_TO_EDGE",SWIG_From_int(static_cast< int >(0x812F)));
  SWIG_Python_SetConstant(d, "GL_CLAMP_TO_BORDER",SWIG_From_int(static_cast< int >(0x812D)));
  SWIG_Python_SetConstant(d, "GL_REPLACE",SWIG_From_int(static_cast< int >(0x1E01)));
  SWIG_Python_SetConstant(d, "GL_MAX_3D_TEXTURE_SIZE",SWIG_From_int(static_cast< int >(0x8073)));
  SWIG_Python_SetConstant(d, "GL_PACK_IMAGE_HEIGHT",SWIG_From_int(static_cast< int >(0x806C)));
  SWIG_Python_SetConstant(d, "GL_PACK_SKIP_IMAGES",SWIG_From_int(static_cast< int >(0x806B)));
  SWIG_Python_SetConstant(d, "GL_PROXY_TEXTURE_2D",SWIG_From_int(static_cast< int >(0x8064)));
  SWIG_Python_SetConstant(d, "GL_PROXY_TEXTURE_3D",SWIG_From_int(static_cast< int >(0x8070)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_3D",SWIG_From_int(static_cast< int >(0x806F)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_DEPTH",SWIG_From_int(static_cast< int >(0x8071)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_WRAP_R",SWIG_From_int(static_cast< int >(0x8072)));
  SWIG_Python_SetConstant(d, "GL_UNPACK_IMAGE_HEIGHT",SWIG_From_int(static_cast< int >(0x806E)));
  SWIG_Python_SetConstant(d, "GL_UNPACK_SKIP_IMAGES",SWIG_From_int(static_cast< int >(0x806D)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_WIDTH",SWIG_From_int(static_cast< int >(0x80D9)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE0",SWIG_From_int(static_cast< int >(0x84C0)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE1",SWIG_From_int(static_cast< int >(0x84C1)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE2",SWIG_From_int(static_cast< int >(0x84C2)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE3",SWIG_From_int(static_cast< int >(0x84C3)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE4",SWIG_From_int(static_cast< int >(0x84C4)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE5",SWIG_From_int(static_cast< int >(0x84C5)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE6",SWIG_From_int(static_cast< int >(0x84C6)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE7",SWIG_From_int(static_cast< int >(0x84C7)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE8",SWIG_From_int(static_cast< int >(0x84C8)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE9",SWIG_From_int(static_cast< int >(0x84C9)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE10",SWIG_From_int(static_cast< int >(0x84CA)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE11",SWIG_From_int(static_cast< int >(0x84CB)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE12",SWIG_From_int(static_cast< int >(0x84CC)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE13",SWIG_From_int(static_cast< int >(0x84CD)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE14",SWIG_From_int(static_cast< int >(0x84CE)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE15",SWIG_From_int(static_cast< int >(0x84CF)));
  SWIG_Python_SetConstant(d, "GL_MAX_TEXTURE_UNITS",SWIG_From_int(static_cast< int >(0x84E2)));
  SWIG_Python_SetConstant(d, "GL_ACTIVE_TEXTURE",SWIG_From_int(static_cast< int >(0x84E0)));
  SWIG_Python_SetConstant(d, "GL_CLIENT_ACTIVE_TEXTURE",SWIG_From_int(static_cast< int >(0x84E1)));
  SWIG_Python_SetConstant(d, "GL_POLYGON_OFFSET_EXT",SWIG_From_int(static_cast< int >(0x8037)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE",SWIG_From_int(static_cast< int >(0x80D0)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX1_EXT",SWIG_From_int(static_cast< int >(0x80E2)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX2_EXT",SWIG_From_int(static_cast< int >(0x80E3)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX4_EXT",SWIG_From_int(static_cast< int >(0x80E4)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX8_EXT",SWIG_From_int(static_cast< int >(0x80E5)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX12_EXT",SWIG_From_int(static_cast< int >(0x80E6)));
  SWIG_Python_SetConstant(d, "GL_COLOR_INDEX16_EXT",SWIG_From_int(static_cast< int >(0x80E7)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_FORMAT_EXT",SWIG_From_int(static_cast< int >(0x80D8)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_RED_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DA)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_GREEN_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DB)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_BLUE_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DC)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_ALPHA_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DD)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_LUMINANCE_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DE)));
  SWIG_Python_SetConstant(d, "GL_COLOR_TABLE_INTENSITY_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80DF)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_INDEX_SIZE_EXT",SWIG_From_int(static_cast< int >(0x80ED)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_ALPHA_ARB",SWIG_From_int(static_cast< int >(0x84E9)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_LUMINANCE_ARB",SWIG_From_int(static_cast< int >(0x84EA)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_LUMINANCE_ALPHA_ARB",SWIG_From_int(static_cast< int >(0x84EB)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_INTENSITY_ARB",SWIG_From_int(static_cast< int >(0x84EC)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_RGB_ARB",SWIG_From_int(static_cast< int >(0x84ED)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_RGBA_ARB",SWIG_From_int(static_cast< int >(0x84EE)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COMPRESSION_HINT_ARB",SWIG_From_int(static_cast< int >(0x84EF)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB",SWIG_From_int(static_cast< int >(0x86A0)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COMPRESSED_ARB",SWIG_From_int(static_cast< int >(0x86A1)));
  SWIG_Python_SetConstant(d, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB",SWIG_From_int(static_cast< int >(0x86A2)));
  SWIG_Python_SetConstant(d, "GL_COMPRESSED_TEXTURE_FORMATS_ARB",SWIG_From_int(static_cast< int >(0x86A3)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_COMPONENT16",SWIG_From_int(static_cast< int >(0x81A5)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_COMPONENT24",SWIG_From_int(static_cast< int >(0x81A6)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_COMPONENT32",SWIG_From_int(static_cast< int >(0x81A7)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_DEPTH_SIZE",SWIG_From_int(static_cast< int >(0x884A)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_TEXTURE_MODE",SWIG_From_int(static_cast< int >(0x884B)));
  SWIG_Python_SetConstant(d, "GL_R3_G3_B2",SWIG_From_int(static_cast< int >(0x2A10)));
  SWIG_Python_SetConstant(d, "GL_RGB4",SWIG_From_int(static_cast< int >(0x804F)));
  SWIG_Python_SetConstant(d, "GL_RGB5",SWIG_From_int(static_cast< int >(0x8050)));
  SWIG_Python_SetConstant(d, "GL_RGB8",SWIG_From_int(static_cast< int >(0x8051)));
  SWIG_Python_SetConstant(d, "GL_RGB10",SWIG_From_int(static_cast< int >(0x8052)));
  SWIG_Python_SetConstant(d, "GL_RGB12",SWIG_From_int(static_cast< int >(0x8053)));
  SWIG_Python_SetConstant(d, "GL_RGB16",SWIG_From_int(static_cast< int >(0x8054)));
  SWIG_Python_SetConstant(d, "GL_RGBA2",SWIG_From_int(static_cast< int >(0x8055)));
  SWIG_Python_SetConstant(d, "GL_RGBA4",SWIG_From_int(static_cast< int >(0x8056)));
  SWIG_Python_SetConstant(d, "GL_RGB5_A1",SWIG_From_int(static_cast< int >(0x8057)));
  SWIG_Python_SetConstant(d, "GL_RGBA8",SWIG_From_int(static_cast< int >(0x8058)));
  SWIG_Python_SetConstant(d, "GL_RGB10_A2",SWIG_From_int(static_cast< int >(0x8059)));
  SWIG_Python_SetConstant(d, "GL_RGBA12",SWIG_From_int(static_cast< int >(0x805A)));
  SWIG_Python_SetConstant(d, "GL_RGBA16",SWIG_From_int(static_cast< int >(0x805B)));
  SWIG_Python_SetConstant(d, "GL_BGR",SWIG_From_int(static_cast< int >(0x80E0)));
  SWIG_Python_SetConstant(d, "GL_RGBA32F_ARB",SWIG_From_int(static_cast< int >(0x8814)));
  SWIG_Python_SetConstant(d, "GL_RGB32F_ARB",SWIG_From_int(static_cast< int >(0x8815)));
  SWIG_Python_SetConstant(d, "GL_ALPHA32F_ARB",SWIG_From_int(static_cast< int >(0x8816)));
  SWIG_Python_SetConstant(d, "GL_INTENSITY32F_ARB",SWIG_From_int(static_cast< int >(0x8817)));
  SWIG_Python_SetConstant(d, "GL_LUMINANCE32F_ARB",SWIG_From_int(static_cast< int >(0x8818)));
  SWIG_Python_SetConstant(d, "GL_LUMINANCE_ALPHA32F_ARB",SWIG_From_int(static_cast< int >(0x8819)));
  SWIG_Python_SetConstant(d, "GL_RGBA16F_ARB",SWIG_From_int(static_cast< int >(0x881A)));
  SWIG_Python_SetConstant(d, "GL_RGB16F_ARB",SWIG_From_int(static_cast< int >(0x881B)));
  SWIG_Python_SetConstant(d, "GL_ALPHA16F_ARB",SWIG_From_int(static_cast< int >(0x881C)));
  SWIG_Python_SetConstant(d, "GL_INTENSITY16F_ARB",SWIG_From_int(static_cast< int >(0x881D)));
  SWIG_Python_SetConstant(d, "GL_LUMINANCE16F_ARB",SWIG_From_int(static_cast< int >(0x881E)));
  SWIG_Python_SetConstant(d, "GL_LUMINANCE_ALPHA16F_ARB",SWIG_From_int(static_cast< int >(0x881F)));
  SWIG_Python_SetConstant(d, "GL_RGBA16_EXT",SWIG_From_int(static_cast< int >(0x805B)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COMPARE_MODE",SWIG_From_int(static_cast< int >(0x884C)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COMPARE_FUNC",SWIG_From_int(static_cast< int >(0x884D)));
  SWIG_Python_SetConstant(d, "GL_COMPARE_R_TO_TEXTURE",SWIG_From_int(static_cast< int >(0x884E)));
  SWIG_Python_SetConstant(d, "GL_MIN",SWIG_From_int(static_cast< int >(0x8007)));
  SWIG_Python_SetConstant(d, "GL_MAX",SWIG_From_int(static_cast< int >(0x8008)));
  SWIG_Python_SetConstant(d, "GL_FUNC_ADD",SWIG_From_int(static_cast< int >(0x8006)));
  SWIG_Python_SetConstant(d, "GL_FUNC_SUBTRACT",SWIG_From_int(static_cast< int >(0x800A)));
  SWIG_Python_SetConstant(d, "GL_FUNC_REVERSE_SUBTRACT",SWIG_From_int(static_cast< int >(0x800B)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ARRAY",SWIG_From_int(static_cast< int >(0x8074)));
  SWIG_Python_SetConstant(d, "GL_NORMAL_ARRAY",SWIG_From_int(static_cast< int >(0x8075)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ARRAY",SWIG_From_int(static_cast< int >(0x8076)));
  SWIG_Python_SetConstant(d, "GL_INDEX_ARRAY",SWIG_From_int(static_cast< int >(0x8077)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_COORD_ARRAY",SWIG_From_int(static_cast< int >(0x8078)));
  SWIG_Python_SetConstant(d, "GL_V3F",SWIG_From_int(static_cast< int >(0x2A21)));
  SWIG_Python_SetConstant(d, "GL_C4UB_V3F",SWIG_From_int(static_cast< int >(0x2A23)));
  SWIG_Python_SetConstant(d, "GL_C3F_V3F",SWIG_From_int(static_cast< int >(0x2A24)));
  SWIG_Python_SetConstant(d, "GL_N3F_V3F",SWIG_From_int(static_cast< int >(0x2A25)));
  SWIG_Python_SetConstant(d, "GL_C4F_N3F_V3F",SWIG_From_int(static_cast< int >(0x2A26)));
  SWIG_Python_SetConstant(d, "GL_T2F_V3F",SWIG_From_int(static_cast< int >(0x2A27)));
  SWIG_Python_SetConstant(d, "GL_T2F_C4UB_V3F",SWIG_From_int(static_cast< int >(0x2A29)));
  SWIG_Python_SetConstant(d, "GL_T2F_C3F_V3F",SWIG_From_int(static_cast< int >(0x2A2A)));
  SWIG_Python_SetConstant(d, "GL_T2F_N3F_V3F",SWIG_From_int(static_cast< int >(0x2A2B)));
  SWIG_Python_SetConstant(d, "GL_T2F_C4F_N3F_V3F",SWIG_From_int(static_cast< int >(0x2A2C)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ARRAY_RANGE_NV",SWIG_From_int(static_cast< int >(0x851D)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ARRAY_RANGE_LENGTH_NV",SWIG_From_int(static_cast< int >(0x851E)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ARRAY_RANGE_VALID_NV",SWIG_From_int(static_cast< int >(0x851F)));
  SWIG_Python_SetConstant(d, "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV",SWIG_From_int(static_cast< int >(0x8520)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ARRAY_RANGE_POINTER_NV",SWIG_From_int(static_cast< int >(0x8521)));
  SWIG_Python_SetConstant(d, "GL_ARRAY_BUFFER",SWIG_From_int(static_cast< int >(0x8892)));
  SWIG_Python_SetConstant(d, "GL_ELEMENT_ARRAY_BUFFER",SWIG_From_int(static_cast< int >(0x8893)));
  SWIG_Python_SetConstant(d, "GL_READ_ONLY",SWIG_From_int(static_cast< int >(0x88B8)));
  SWIG_Python_SetConstant(d, "GL_WRITE_ONLY",SWIG_From_int(static_cast< int >(0x88B9)));
  SWIG_Python_SetConstant(d, "GL_READ_WRITE",SWIG_From_int(static_cast< int >(0x88BA)));
  SWIG_Python_SetConstant(d, "GL_BUFFER_ACCESS",SWIG_From_int(static_cast< int >(0x88BB)));
  SWIG_Python_SetConstant(d, "GL_BUFFER_MAPPED",SWIG_From_int(static_cast< int >(0x88BC)));
  SWIG_Python_SetConstant(d, "GL_BUFFER_MAP_POINTER",SWIG_From_int(static_cast< int >(0x88BD)));
  SWIG_Python_SetConstant(d, "GL_STREAM_DRAW",SWIG_From_int(static_cast< int >(0x88E0)));
  SWIG_Python_SetConstant(d, "GL_STREAM_READ",SWIG_From_int(static_cast< int >(0x88E1)));
  SWIG_Python_SetConstant(d, "GL_STREAM_COPY",SWIG_From_int(static_cast< int >(0x88E2)));
  SWIG_Python_SetConstant(d, "GL_STATIC_DRAW",SWIG_From_int(static_cast< int >(0x88E4)));
  SWIG_Python_SetConstant(d, "GL_STATIC_READ",SWIG_From_int(static_cast< int >(0x88E5)));
  SWIG_Python_SetConstant(d, "GL_STATIC_COPY",SWIG_From_int(static_cast< int >(0x88E6)));
  SWIG_Python_SetConstant(d, "GL_DYNAMIC_DRAW",SWIG_From_int(static_cast< int >(0x88E8)));
  SWIG_Python_SetConstant(d, "GL_DYNAMIC_READ",SWIG_From_int(static_cast< int >(0x88E9)));
  SWIG_Python_SetConstant(d, "GL_DYNAMIC_COPY",SWIG_From_int(static_cast< int >(0x88EA)));
  SWIG_Python_SetConstant(d, "GL_REGISTER_COMBINERS_NV",SWIG_From_int(static_cast< int >(0x8522)));
  SWIG_Python_SetConstant(d, "GL_COMBINER0_NV",SWIG_From_int(static_cast< int >(0x8550)));
  SWIG_Python_SetConstant(d, "GL_COMBINER1_NV",SWIG_From_int(static_cast< int >(0x8551)));
  SWIG_Python_SetConstant(d, "GL_COMBINER2_NV",SWIG_From_int(static_cast< int >(0x8552)));
  SWIG_Python_SetConstant(d, "GL_COMBINER3_NV",SWIG_From_int(static_cast< int >(0x8553)));
  SWIG_Python_SetConstant(d, "GL_COMBINER4_NV",SWIG_From_int(static_cast< int >(0x8554)));
  SWIG_Python_SetConstant(d, "GL_COMBINER5_NV",SWIG_From_int(static_cast< int >(0x8555)));
  SWIG_Python_SetConstant(d, "GL_COMBINER6_NV",SWIG_From_int(static_cast< int >(0x8556)));
  SWIG_Python_SetConstant(d, "GL_COMBINER7_NV",SWIG_From_int(static_cast< int >(0x8557)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_A_NV",SWIG_From_int(static_cast< int >(0x8523)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_B_NV",SWIG_From_int(static_cast< int >(0x8524)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_C_NV",SWIG_From_int(static_cast< int >(0x8525)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_D_NV",SWIG_From_int(static_cast< int >(0x8526)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_E_NV",SWIG_From_int(static_cast< int >(0x8527)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_F_NV",SWIG_From_int(static_cast< int >(0x8528)));
  SWIG_Python_SetConstant(d, "GL_VARIABLE_G_NV",SWIG_From_int(static_cast< int >(0x8529)));
  SWIG_Python_SetConstant(d, "GL_CONSTANT_COLOR0_NV",SWIG_From_int(static_cast< int >(0x852A)));
  SWIG_Python_SetConstant(d, "GL_CONSTANT_COLOR1_NV",SWIG_From_int(static_cast< int >(0x852B)));
  SWIG_Python_SetConstant(d, "GL_PRIMARY_COLOR_NV",SWIG_From_int(static_cast< int >(0x852C)));
  SWIG_Python_SetConstant(d, "GL_SECONDARY_COLOR_NV",SWIG_From_int(static_cast< int >(0x852D)));
  SWIG_Python_SetConstant(d, "GL_SPARE0_NV",SWIG_From_int(static_cast< int >(0x852E)));
  SWIG_Python_SetConstant(d, "GL_SPARE1_NV",SWIG_From_int(static_cast< int >(0x852F)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_IDENTITY_NV",SWIG_From_int(static_cast< int >(0x8536)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_INVERT_NV",SWIG_From_int(static_cast< int >(0x8537)));
  SWIG_Python_SetConstant(d, "GL_EXPAND_NORMAL_NV",SWIG_From_int(static_cast< int >(0x8538)));
  SWIG_Python_SetConstant(d, "GL_EXPAND_NEGATE_NV",SWIG_From_int(static_cast< int >(0x8539)));
  SWIG_Python_SetConstant(d, "GL_HALF_BIAS_NORMAL_NV",SWIG_From_int(static_cast< int >(0x853A)));
  SWIG_Python_SetConstant(d, "GL_HALF_BIAS_NEGATE_NV",SWIG_From_int(static_cast< int >(0x853B)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_IDENTITY_NV",SWIG_From_int(static_cast< int >(0x853C)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_NEGATE_NV",SWIG_From_int(static_cast< int >(0x853D)));
  SWIG_Python_SetConstant(d, "GL_E_TIMES_F_NV",SWIG_From_int(static_cast< int >(0x8531)));
  SWIG_Python_SetConstant(d, "GL_SPARE0_PLUS_SECONDARY_COLOR_NV",SWIG_From_int(static_cast< int >(0x8532)));
  SWIG_Python_SetConstant(d, "GL_SCALE_BY_TWO_NV",SWIG_From_int(static_cast< int >(0x853E)));
  SWIG_Python_SetConstant(d, "GL_SCALE_BY_FOUR_NV",SWIG_From_int(static_cast< int >(0x853F)));
  SWIG_Python_SetConstant(d, "GL_SCALE_BY_ONE_HALF_NV",SWIG_From_int(static_cast< int >(0x8540)));
  SWIG_Python_SetConstant(d, "GL_BIAS_BY_NEGATIVE_ONE_HALF_NV",SWIG_From_int(static_cast< int >(0x8541)));
  SWIG_Python_SetConstant(d, "GL_DISCARD_NV",SWIG_From_int(static_cast< int >(0x8530)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_INPUT_NV",SWIG_From_int(static_cast< int >(0x8542)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_MAPPING_NV",SWIG_From_int(static_cast< int >(0x8543)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_COMPONENT_USAGE_NV",SWIG_From_int(static_cast< int >(0x8544)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_AB_DOT_PRODUCT_NV",SWIG_From_int(static_cast< int >(0x8545)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_CD_DOT_PRODUCT_NV",SWIG_From_int(static_cast< int >(0x8546)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_MUX_SUM_NV",SWIG_From_int(static_cast< int >(0x8547)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_SCALE_NV",SWIG_From_int(static_cast< int >(0x8548)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_BIAS_NV",SWIG_From_int(static_cast< int >(0x8549)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_AB_OUTPUT_NV",SWIG_From_int(static_cast< int >(0x854A)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_CD_OUTPUT_NV",SWIG_From_int(static_cast< int >(0x854B)));
  SWIG_Python_SetConstant(d, "GL_COMBINER_SUM_OUTPUT_NV",SWIG_From_int(static_cast< int >(0x854C)));
  SWIG_Python_SetConstant(d, "GL_MAX_GENERAL_COMBINERS_NV",SWIG_From_int(static_cast< int >(0x854D)));
  SWIG_Python_SetConstant(d, "GL_NUM_GENERAL_COMBINERS_NV",SWIG_From_int(static_cast< int >(0x854E)));
  SWIG_Python_SetConstant(d, "GL_COLOR_SUM_CLAMP_NV",SWIG_From_int(static_cast< int >(0x854F)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_RECTANGLE_NV",SWIG_From_int(static_cast< int >(0x84F5)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_BINDING_RECTANGLE_NV",SWIG_From_int(static_cast< int >(0x84F6)));
  SWIG_Python_SetConstant(d, "GL_PROXY_TEXTURE_RECTANGLE_NV",SWIG_From_int(static_cast< int >(0x84F7)));
  SWIG_Python_SetConstant(d, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV",SWIG_From_int(static_cast< int >(0x84F8)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_RECTANGLE_EXT",SWIG_From_int(static_cast< int >(0x84F5)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_BINDING_RECTANGLE_EXT",SWIG_From_int(static_cast< int >(0x84F6)));
  SWIG_Python_SetConstant(d, "GL_PROXY_TEXTURE_RECTANGLE_EXT",SWIG_From_int(static_cast< int >(0x84F7)));
  SWIG_Python_SetConstant(d, "GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT",SWIG_From_int(static_cast< int >(0x84F8)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_RECTANGLE_NV",SWIG_From_int(static_cast< int >(0x864C)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV",SWIG_From_int(static_cast< int >(0x864D)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV",SWIG_From_int(static_cast< int >(0x864E)));
  SWIG_Python_SetConstant(d, "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV",SWIG_From_int(static_cast< int >(0x86D9)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_INT_S8_S8_8_8_NV",SWIG_From_int(static_cast< int >(0x86DA)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV",SWIG_From_int(static_cast< int >(0x86DB)));
  SWIG_Python_SetConstant(d, "GL_DSDT_MAG_INTENSITY_NV",SWIG_From_int(static_cast< int >(0x86DC)));
  SWIG_Python_SetConstant(d, "GL_SHADER_CONSISTENT_NV",SWIG_From_int(static_cast< int >(0x86DD)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_SHADER_NV",SWIG_From_int(static_cast< int >(0x86DE)));
  SWIG_Python_SetConstant(d, "GL_SHADER_OPERATION_NV",SWIG_From_int(static_cast< int >(0x86DF)));
  SWIG_Python_SetConstant(d, "GL_CULL_MODES_NV",SWIG_From_int(static_cast< int >(0x86E0)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_MATRIX_NV",SWIG_From_int(static_cast< int >(0x86E1)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_SCALE_NV",SWIG_From_int(static_cast< int >(0x86E2)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_BIAS_NV",SWIG_From_int(static_cast< int >(0x86E3)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_2D_MATRIX_NV",SWIG_From_int(static_cast< int >(0x86E1)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_2D_SCALE_NV",SWIG_From_int(static_cast< int >(0x86E2)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_2D_BIAS_NV",SWIG_From_int(static_cast< int >(0x86E3)));
  SWIG_Python_SetConstant(d, "GL_PREVIOUS_TEXTURE_INPUT_NV",SWIG_From_int(static_cast< int >(0x86E4)));
  SWIG_Python_SetConstant(d, "GL_CONST_EYE_NV",SWIG_From_int(static_cast< int >(0x86E5)));
  SWIG_Python_SetConstant(d, "GL_PASS_THROUGH_NV",SWIG_From_int(static_cast< int >(0x86E6)));
  SWIG_Python_SetConstant(d, "GL_CULL_FRAGMENT_NV",SWIG_From_int(static_cast< int >(0x86E7)));
  SWIG_Python_SetConstant(d, "GL_OFFSET_TEXTURE_2D_NV",SWIG_From_int(static_cast< int >(0x86E8)));
  SWIG_Python_SetConstant(d, "GL_DEPENDENT_AR_TEXTURE_2D_NV",SWIG_From_int(static_cast< int >(0x86E9)));
  SWIG_Python_SetConstant(d, "GL_DEPENDENT_GB_TEXTURE_2D_NV",SWIG_From_int(static_cast< int >(0x86EA)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_NV",SWIG_From_int(static_cast< int >(0x86EC)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_DEPTH_REPLACE_NV",SWIG_From_int(static_cast< int >(0x86ED)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_TEXTURE_2D_NV",SWIG_From_int(static_cast< int >(0x86EE)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV",SWIG_From_int(static_cast< int >(0x86F0)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV",SWIG_From_int(static_cast< int >(0x86F1)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV",SWIG_From_int(static_cast< int >(0x86F2)));
  SWIG_Python_SetConstant(d, "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV",SWIG_From_int(static_cast< int >(0x86F3)));
  SWIG_Python_SetConstant(d, "GL_HILO_NV",SWIG_From_int(static_cast< int >(0x86F4)));
  SWIG_Python_SetConstant(d, "GL_DSDT_NV",SWIG_From_int(static_cast< int >(0x86F5)));
  SWIG_Python_SetConstant(d, "GL_DSDT_MAG_NV",SWIG_From_int(static_cast< int >(0x86F6)));
  SWIG_Python_SetConstant(d, "GL_DSDT_MAG_VIB_NV",SWIG_From_int(static_cast< int >(0x86F7)));
  SWIG_Python_SetConstant(d, "GL_HILO16_NV",SWIG_From_int(static_cast< int >(0x86F8)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_HILO_NV",SWIG_From_int(static_cast< int >(0x86F9)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_HILO16_NV",SWIG_From_int(static_cast< int >(0x86FA)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGBA_NV",SWIG_From_int(static_cast< int >(0x86FB)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGBA8_NV",SWIG_From_int(static_cast< int >(0x86FC)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGB_NV",SWIG_From_int(static_cast< int >(0x86FE)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGB8_NV",SWIG_From_int(static_cast< int >(0x86FF)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_LUMINANCE_NV",SWIG_From_int(static_cast< int >(0x8701)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_LUMINANCE8_NV",SWIG_From_int(static_cast< int >(0x8702)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_LUMINANCE_ALPHA_NV",SWIG_From_int(static_cast< int >(0x8703)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_LUMINANCE8_ALPHA8_NV",SWIG_From_int(static_cast< int >(0x8704)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_ALPHA_NV",SWIG_From_int(static_cast< int >(0x8705)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_ALPHA8_NV",SWIG_From_int(static_cast< int >(0x8706)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_INTENSITY_NV",SWIG_From_int(static_cast< int >(0x8707)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_INTENSITY8_NV",SWIG_From_int(static_cast< int >(0x8708)));
  SWIG_Python_SetConstant(d, "GL_DSDT8_NV",SWIG_From_int(static_cast< int >(0x8709)));
  SWIG_Python_SetConstant(d, "GL_DSDT8_MAG8_NV",SWIG_From_int(static_cast< int >(0x870A)));
  SWIG_Python_SetConstant(d, "GL_DSDT8_MAG8_INTENSITY8_NV",SWIG_From_int(static_cast< int >(0x870B)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV",SWIG_From_int(static_cast< int >(0x870C)));
  SWIG_Python_SetConstant(d, "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV",SWIG_From_int(static_cast< int >(0x870D)));
  SWIG_Python_SetConstant(d, "GL_HI_SCALE_NV",SWIG_From_int(static_cast< int >(0x870E)));
  SWIG_Python_SetConstant(d, "GL_LO_SCALE_NV",SWIG_From_int(static_cast< int >(0x870F)));
  SWIG_Python_SetConstant(d, "GL_DS_SCALE_NV",SWIG_From_int(static_cast< int >(0x8710)));
  SWIG_Python_SetConstant(d, "GL_DT_SCALE_NV",SWIG_From_int(static_cast< int >(0x8711)));
  SWIG_Python_SetConstant(d, "GL_MAGNITUDE_SCALE_NV",SWIG_From_int(static_cast< int >(0x8712)));
  SWIG_Python_SetConstant(d, "GL_VIBRANCE_SCALE_NV",SWIG_From_int(static_cast< int >(0x8713)));
  SWIG_Python_SetConstant(d, "GL_HI_BIAS_NV",SWIG_From_int(static_cast< int >(0x8714)));
  SWIG_Python_SetConstant(d, "GL_LO_BIAS_NV",SWIG_From_int(static_cast< int >(0x8715)));
  SWIG_Python_SetConstant(d, "GL_DS_BIAS_NV",SWIG_From_int(static_cast< int >(0x8716)));
  SWIG_Python_SetConstant(d, "GL_DT_BIAS_NV",SWIG_From_int(static_cast< int >(0x8717)));
  SWIG_Python_SetConstant(d, "GL_MAGNITUDE_BIAS_NV",SWIG_From_int(static_cast< int >(0x8718)));
  SWIG_Python_SetConstant(d, "GL_VIBRANCE_BIAS_NV",SWIG_From_int(static_cast< int >(0x8719)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_BORDER_VALUES_NV",SWIG_From_int(static_cast< int >(0x871A)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_HI_SIZE_NV",SWIG_From_int(static_cast< int >(0x871B)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_LO_SIZE_NV",SWIG_From_int(static_cast< int >(0x871C)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_DS_SIZE_NV",SWIG_From_int(static_cast< int >(0x871D)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_DT_SIZE_NV",SWIG_From_int(static_cast< int >(0x871E)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_MAG_SIZE_NV",SWIG_From_int(static_cast< int >(0x871F)));
  SWIG_Python_SetConstant(d, "GL_NORMAL_MAP",SWIG_From_int(static_cast< int >(0x8511)));
  SWIG_Python_SetConstant(d, "GL_REFLECTION_MAP",SWIG_From_int(static_cast< int >(0x8512)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP",SWIG_From_int(static_cast< int >(0x8513)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_BINDING_CUBE_MAP",SWIG_From_int(static_cast< int >(0x8514)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_POSITIVE_X",SWIG_From_int(static_cast< int >(0x8515)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X",SWIG_From_int(static_cast< int >(0x8516)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_POSITIVE_Y",SWIG_From_int(static_cast< int >(0x8517)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y",SWIG_From_int(static_cast< int >(0x8518)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_POSITIVE_Z",SWIG_From_int(static_cast< int >(0x8519)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z",SWIG_From_int(static_cast< int >(0x851A)));
  SWIG_Python_SetConstant(d, "GL_MAX_CUBE_MAP_TEXTURE_SIZE",SWIG_From_int(static_cast< int >(0x851C)));
  SWIG_Python_SetConstant(d, "GL_COMBINE",SWIG_From_int(static_cast< int >(0x8570)));
  SWIG_Python_SetConstant(d, "GL_COMBINE_RGB",SWIG_From_int(static_cast< int >(0x8571)));
  SWIG_Python_SetConstant(d, "GL_COMBINE_ALPHA",SWIG_From_int(static_cast< int >(0x8572)));
  SWIG_Python_SetConstant(d, "GL_RGB_SCALE",SWIG_From_int(static_cast< int >(0x8573)));
  SWIG_Python_SetConstant(d, "GL_ADD_SIGNED",SWIG_From_int(static_cast< int >(0x8574)));
  SWIG_Python_SetConstant(d, "GL_INTERPOLATE",SWIG_From_int(static_cast< int >(0x8575)));
  SWIG_Python_SetConstant(d, "GL_CONSTANT",SWIG_From_int(static_cast< int >(0x8576)));
  SWIG_Python_SetConstant(d, "GL_PRIMARY_COLOR",SWIG_From_int(static_cast< int >(0x8577)));
  SWIG_Python_SetConstant(d, "GL_PREVIOUS",SWIG_From_int(static_cast< int >(0x8578)));
  SWIG_Python_SetConstant(d, "GL_SOURCE0_RGB",SWIG_From_int(static_cast< int >(0x8580)));
  SWIG_Python_SetConstant(d, "GL_SOURCE1_RGB",SWIG_From_int(static_cast< int >(0x8581)));
  SWIG_Python_SetConstant(d, "GL_SOURCE2_RGB",SWIG_From_int(static_cast< int >(0x8582)));
  SWIG_Python_SetConstant(d, "GL_SOURCE0_ALPHA",SWIG_From_int(static_cast< int >(0x8588)));
  SWIG_Python_SetConstant(d, "GL_SOURCE1_ALPHA",SWIG_From_int(static_cast< int >(0x8589)));
  SWIG_Python_SetConstant(d, "GL_SOURCE2_ALPHA",SWIG_From_int(static_cast< int >(0x858A)));
  SWIG_Python_SetConstant(d, "GL_OPERAND0_RGB",SWIG_From_int(static_cast< int >(0x8590)));
  SWIG_Python_SetConstant(d, "GL_OPERAND1_RGB",SWIG_From_int(static_cast< int >(0x8591)));
  SWIG_Python_SetConstant(d, "GL_OPERAND2_RGB",SWIG_From_int(static_cast< int >(0x8592)));
  SWIG_Python_SetConstant(d, "GL_OPERAND0_ALPHA",SWIG_From_int(static_cast< int >(0x8598)));
  SWIG_Python_SetConstant(d, "GL_OPERAND1_ALPHA",SWIG_From_int(static_cast< int >(0x8599)));
  SWIG_Python_SetConstant(d, "GL_OPERAND2_ALPHA",SWIG_From_int(static_cast< int >(0x859A)));
  SWIG_Python_SetConstant(d, "GL_SUBTRACT",SWIG_From_int(static_cast< int >(0x84E7)));
  SWIG_Python_SetConstant(d, "GL_DOT3_RGB",SWIG_From_int(static_cast< int >(0x86AE)));
  SWIG_Python_SetConstant(d, "GL_DOT3_RGBA",SWIG_From_int(static_cast< int >(0x86AF)));
  SWIG_Python_SetConstant(d, "GL_GENERATE_MIPMAP_SGIS",SWIG_From_int(static_cast< int >(0x8191)));
  SWIG_Python_SetConstant(d, "GL_GENERATE_MIPMAP_HINT_SGIS",SWIG_From_int(static_cast< int >(0x8192)));
  SWIG_Python_SetConstant(d, "GL_FRAGMENT_PROGRAM_ARB",SWIG_From_int(static_cast< int >(0x8804)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_FORMAT_ASCII_ARB",SWIG_From_int(static_cast< int >(0x8875)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_LENGTH_ARB",SWIG_From_int(static_cast< int >(0x8627)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_FORMAT_ARB",SWIG_From_int(static_cast< int >(0x8876)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_BINDING_ARB",SWIG_From_int(static_cast< int >(0x8677)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x88A0)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x88A1)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x88A2)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x88A3)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_TEMPORARIES_ARB",SWIG_From_int(static_cast< int >(0x88A4)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_TEMPORARIES_ARB",SWIG_From_int(static_cast< int >(0x88A5)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_TEMPORARIES_ARB",SWIG_From_int(static_cast< int >(0x88A6)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB",SWIG_From_int(static_cast< int >(0x88A7)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88A8)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88A9)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88AA)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88AB)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_ATTRIBS_ARB",SWIG_From_int(static_cast< int >(0x88AC)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_ATTRIBS_ARB",SWIG_From_int(static_cast< int >(0x88AD)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_ATTRIBS_ARB",SWIG_From_int(static_cast< int >(0x88AE)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB",SWIG_From_int(static_cast< int >(0x88AF)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88B4)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB",SWIG_From_int(static_cast< int >(0x88B5)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB",SWIG_From_int(static_cast< int >(0x88B6)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_ALU_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x8805)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_TEX_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x8806)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_TEX_INDIRECTIONS_ARB",SWIG_From_int(static_cast< int >(0x8807)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x8808)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x8809)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB",SWIG_From_int(static_cast< int >(0x880A)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x880B)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x880C)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB",SWIG_From_int(static_cast< int >(0x880D)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x880E)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB",SWIG_From_int(static_cast< int >(0x880F)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB",SWIG_From_int(static_cast< int >(0x8810)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_STRING_ARB",SWIG_From_int(static_cast< int >(0x8628)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_ERROR_POSITION_ARB",SWIG_From_int(static_cast< int >(0x864B)));
  SWIG_Python_SetConstant(d, "GL_CURRENT_MATRIX_ARB",SWIG_From_int(static_cast< int >(0x8641)));
  SWIG_Python_SetConstant(d, "GL_TRANSPOSE_CURRENT_MATRIX_ARB",SWIG_From_int(static_cast< int >(0x88B7)));
  SWIG_Python_SetConstant(d, "GL_CURRENT_MATRIX_STACK_DEPTH_ARB",SWIG_From_int(static_cast< int >(0x8640)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_MATRICES_ARB",SWIG_From_int(static_cast< int >(0x862F)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB",SWIG_From_int(static_cast< int >(0x862E)));
  SWIG_Python_SetConstant(d, "GL_MAX_TEXTURE_COORDS_ARB",SWIG_From_int(static_cast< int >(0x8871)));
  SWIG_Python_SetConstant(d, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB",SWIG_From_int(static_cast< int >(0x8872)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_ERROR_STRING_ARB",SWIG_From_int(static_cast< int >(0x8874)));
  SWIG_Python_SetConstant(d, "GL_MATRIX0_ARB",SWIG_From_int(static_cast< int >(0x88C0)));
  SWIG_Python_SetConstant(d, "GL_MATRIX1_ARB",SWIG_From_int(static_cast< int >(0x88C1)));
  SWIG_Python_SetConstant(d, "GL_MATRIX2_ARB",SWIG_From_int(static_cast< int >(0x88C2)));
  SWIG_Python_SetConstant(d, "GL_MATRIX3_ARB",SWIG_From_int(static_cast< int >(0x88C3)));
  SWIG_Python_SetConstant(d, "GL_MATRIX4_ARB",SWIG_From_int(static_cast< int >(0x88C4)));
  SWIG_Python_SetConstant(d, "GL_MATRIX5_ARB",SWIG_From_int(static_cast< int >(0x88C5)));
  SWIG_Python_SetConstant(d, "GL_MATRIX6_ARB",SWIG_From_int(static_cast< int >(0x88C6)));
  SWIG_Python_SetConstant(d, "GL_MATRIX7_ARB",SWIG_From_int(static_cast< int >(0x88C7)));
  SWIG_Python_SetConstant(d, "GL_MATRIX8_ARB",SWIG_From_int(static_cast< int >(0x88C8)));
  SWIG_Python_SetConstant(d, "GL_MATRIX9_ARB",SWIG_From_int(static_cast< int >(0x88C9)));
  SWIG_Python_SetConstant(d, "GL_MATRIX10_ARB",SWIG_From_int(static_cast< int >(0x88CA)));
  SWIG_Python_SetConstant(d, "GL_MATRIX11_ARB",SWIG_From_int(static_cast< int >(0x88CB)));
  SWIG_Python_SetConstant(d, "GL_MATRIX12_ARB",SWIG_From_int(static_cast< int >(0x88CC)));
  SWIG_Python_SetConstant(d, "GL_MATRIX13_ARB",SWIG_From_int(static_cast< int >(0x88CD)));
  SWIG_Python_SetConstant(d, "GL_MATRIX14_ARB",SWIG_From_int(static_cast< int >(0x88CE)));
  SWIG_Python_SetConstant(d, "GL_MATRIX15_ARB",SWIG_From_int(static_cast< int >(0x88CF)));
  SWIG_Python_SetConstant(d, "GL_MATRIX16_ARB",SWIG_From_int(static_cast< int >(0x88D0)));
  SWIG_Python_SetConstant(d, "GL_MATRIX17_ARB",SWIG_From_int(static_cast< int >(0x88D1)));
  SWIG_Python_SetConstant(d, "GL_MATRIX18_ARB",SWIG_From_int(static_cast< int >(0x88D2)));
  SWIG_Python_SetConstant(d, "GL_MATRIX19_ARB",SWIG_From_int(static_cast< int >(0x88D3)));
  SWIG_Python_SetConstant(d, "GL_MATRIX20_ARB",SWIG_From_int(static_cast< int >(0x88D4)));
  SWIG_Python_SetConstant(d, "GL_MATRIX21_ARB",SWIG_From_int(static_cast< int >(0x88D5)));
  SWIG_Python_SetConstant(d, "GL_MATRIX22_ARB",SWIG_From_int(static_cast< int >(0x88D6)));
  SWIG_Python_SetConstant(d, "GL_MATRIX23_ARB",SWIG_From_int(static_cast< int >(0x88D7)));
  SWIG_Python_SetConstant(d, "GL_MATRIX24_ARB",SWIG_From_int(static_cast< int >(0x88D8)));
  SWIG_Python_SetConstant(d, "GL_MATRIX25_ARB",SWIG_From_int(static_cast< int >(0x88D9)));
  SWIG_Python_SetConstant(d, "GL_MATRIX26_ARB",SWIG_From_int(static_cast< int >(0x88DA)));
  SWIG_Python_SetConstant(d, "GL_MATRIX27_ARB",SWIG_From_int(static_cast< int >(0x88DB)));
  SWIG_Python_SetConstant(d, "GL_MATRIX28_ARB",SWIG_From_int(static_cast< int >(0x88DC)));
  SWIG_Python_SetConstant(d, "GL_MATRIX29_ARB",SWIG_From_int(static_cast< int >(0x88DD)));
  SWIG_Python_SetConstant(d, "GL_MATRIX30_ARB",SWIG_From_int(static_cast< int >(0x88DE)));
  SWIG_Python_SetConstant(d, "GL_MATRIX31_ARB",SWIG_From_int(static_cast< int >(0x88DF)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_PROGRAM_ARB",SWIG_From_int(static_cast< int >(0x8620)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_PROGRAM_POINT_SIZE_ARB",SWIG_From_int(static_cast< int >(0x8642)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_PROGRAM_TWO_SIDE_ARB",SWIG_From_int(static_cast< int >(0x8643)));
  SWIG_Python_SetConstant(d, "GL_COLOR_SUM_ARB",SWIG_From_int(static_cast< int >(0x8458)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB",SWIG_From_int(static_cast< int >(0x8622)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB",SWIG_From_int(static_cast< int >(0x8623)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB",SWIG_From_int(static_cast< int >(0x8624)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB",SWIG_From_int(static_cast< int >(0x8625)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB",SWIG_From_int(static_cast< int >(0x886A)));
  SWIG_Python_SetConstant(d, "GL_CURRENT_VERTEX_ATTRIB_ARB",SWIG_From_int(static_cast< int >(0x8626)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB",SWIG_From_int(static_cast< int >(0x8645)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_ADDRESS_REGISTERS_ARB",SWIG_From_int(static_cast< int >(0x88B0)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB",SWIG_From_int(static_cast< int >(0x88B1)));
  SWIG_Python_SetConstant(d, "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB",SWIG_From_int(static_cast< int >(0x88B2)));
  SWIG_Python_SetConstant(d, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB",SWIG_From_int(static_cast< int >(0x88B3)));
  SWIG_Python_SetConstant(d, "GL_MAX_VERTEX_ATTRIBS_ARB",SWIG_From_int(static_cast< int >(0x8869)));
  SWIG_Python_SetConstant(d, "GL_VERTEX_SHADER_ARB",SWIG_From_int(static_cast< int >(0x8B31)));
  SWIG_Python_SetConstant(d, "GL_FRAGMENT_SHADER_ARB",SWIG_From_int(static_cast< int >(0x8B30)));
  SWIG_Python_SetConstant(d, "GL_OBJECT_ACTIVE_UNIFORMS_ARB",SWIG_From_int(static_cast< int >(0x8B86)));
  SWIG_Python_SetConstant(d, "GL_GEOMETRY_SHADER_EXT",SWIG_From_int(static_cast< int >(0x8DD9)));
  SWIG_Python_SetConstant(d, "GL_GEOMETRY_VERTICES_OUT_EXT",SWIG_From_int(static_cast< int >(0x8DDA)));
  SWIG_Python_SetConstant(d, "GL_GEOMETRY_INPUT_TYPE_EXT",SWIG_From_int(static_cast< int >(0x8DDB)));
  SWIG_Python_SetConstant(d, "GL_GEOMETRY_OUTPUT_TYPE_EXT",SWIG_From_int(static_cast< int >(0x8DDC)));
  SWIG_Python_SetConstant(d, "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT",SWIG_From_int(static_cast< int >(0x8DE0)));
  SWIG_Python_SetConstant(d, "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT",SWIG_From_int(static_cast< int >(0x8DE1)));
  SWIG_Python_SetConstant(d, "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT",SWIG_From_int(static_cast< int >(0x8C29)));
  SWIG_Python_SetConstant(d, "GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT",SWIG_From_int(static_cast< int >(0x8DDD)));
  SWIG_Python_SetConstant(d, "GL_MAX_VERTEX_VARYING_COMPONENTS_EXT",SWIG_From_int(static_cast< int >(0x8DDE)));
  SWIG_Python_SetConstant(d, "GL_MAX_VARYING_COMPONENTS_EXT",SWIG_From_int(static_cast< int >(0x8B4B)));
  SWIG_Python_SetConstant(d, "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT",SWIG_From_int(static_cast< int >(0x8DDF)));
  SWIG_Python_SetConstant(d, "GL_INT_VEC2_ARB",SWIG_From_int(static_cast< int >(0x8B53)));
  SWIG_Python_SetConstant(d, "GL_INT_VEC3_ARB",SWIG_From_int(static_cast< int >(0x8B54)));
  SWIG_Python_SetConstant(d, "GL_INT_VEC4_ARB",SWIG_From_int(static_cast< int >(0x8B55)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_VEC2_ARB",SWIG_From_int(static_cast< int >(0x8B50)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_VEC3_ARB",SWIG_From_int(static_cast< int >(0x8B51)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_VEC4_ARB",SWIG_From_int(static_cast< int >(0x8B52)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_MAT2_ARB",SWIG_From_int(static_cast< int >(0x8B5A)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_MAT3_ARB",SWIG_From_int(static_cast< int >(0x8B5B)));
  SWIG_Python_SetConstant(d, "GL_FLOAT_MAT4_ARB",SWIG_From_int(static_cast< int >(0x8B5C)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_1D_ARB",SWIG_From_int(static_cast< int >(0x8B5D)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_2D_ARB",SWIG_From_int(static_cast< int >(0x8B5E)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_3D_ARB",SWIG_From_int(static_cast< int >(0x8B5F)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_CUBE_ARB",SWIG_From_int(static_cast< int >(0x8B60)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_1D_SHADOW_ARB",SWIG_From_int(static_cast< int >(0x8B61)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_2D_SHADOW_ARB",SWIG_From_int(static_cast< int >(0x8B62)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_2D_RECT_ARB",SWIG_From_int(static_cast< int >(0x8B63)));
  SWIG_Python_SetConstant(d, "GL_SAMPLER_2D_RECT_SHADOW_ARB",SWIG_From_int(static_cast< int >(0x8B64)));
  SWIG_Python_SetConstant(d, "GL_OBJECT_COMPILE_STATUS_ARB",SWIG_From_int(static_cast< int >(0x8B81)));
  SWIG_Python_SetConstant(d, "GL_OBJECT_INFO_LOG_LENGTH_ARB",SWIG_From_int(static_cast< int >(0x8B84)));
  SWIG_Python_SetConstant(d, "GL_OBJECT_LINK_STATUS_ARB",SWIG_From_int(static_cast< int >(0x8B82)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_MAX_ANISOTROPY_EXT",SWIG_From_int(static_cast< int >(0x84FE)));
  SWIG_Python_SetConstant(d, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT",SWIG_From_int(static_cast< int >(0x84FF)));
  SWIG_Python_SetConstant(d, "GL_SAMPLES_PASSED",SWIG_From_int(static_cast< int >(0x8914)));
  SWIG_Python_SetConstant(d, "GL_QUERY_COUNTER_BITS",SWIG_From_int(static_cast< int >(0x8864)));
  SWIG_Python_SetConstant(d, "GL_CURRENT_QUERY",SWIG_From_int(static_cast< int >(0x8865)));
  SWIG_Python_SetConstant(d, "GL_QUERY_RESULT",SWIG_From_int(static_cast< int >(0x8866)));
  SWIG_Python_SetConstant(d, "GL_QUERY_RESULT_AVAILABLE",SWIG_From_int(static_cast< int >(0x8867)));
  SWIG_Python_SetConstant(d, "GL_CLIENT_PIXEL_STORE_BIT",SWIG_From_int(static_cast< int >(0x00000001)));
  SWIG_Python_SetConstant(d, "GL_CLIENT_VERTEX_ARRAY_BIT",SWIG_From_int(static_cast< int >(0x00000002)));
  SWIG_Python_SetConstant(d, "GL_CLIENT_ALL_ATTRIB_BITS",SWIG_From_int(static_cast< int >(0xFFFFFFFF)));
  SWIG_Python_SetConstant(d, "GL_ALL_CLIENT_ATTRIB_BITS",SWIG_From_int(static_cast< int >(0xFFFFFFFF)));
  SWIG_Python_SetConstant(d, "GL_INVALID_FRAMEBUFFER_OPERATION_EXT",SWIG_From_int(static_cast< int >(0x0506)));
  SWIG_Python_SetConstant(d, "GL_MAX_RENDERBUFFER_SIZE_EXT",SWIG_From_int(static_cast< int >(0x84E8)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_BINDING_EXT",SWIG_From_int(static_cast< int >(0x8CA6)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_BINDING_EXT",SWIG_From_int(static_cast< int >(0x8CA7)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT",SWIG_From_int(static_cast< int >(0x8CD0)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT",SWIG_From_int(static_cast< int >(0x8CD1)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT",SWIG_From_int(static_cast< int >(0x8CD2)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT",SWIG_From_int(static_cast< int >(0x8CD3)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT",SWIG_From_int(static_cast< int >(0x8CD4)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_COMPLETE_EXT",SWIG_From_int(static_cast< int >(0x8CD5)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT",SWIG_From_int(static_cast< int >(0x8CD6)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT",SWIG_From_int(static_cast< int >(0x8CD7)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT",SWIG_From_int(static_cast< int >(0x8CD8)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT",SWIG_From_int(static_cast< int >(0x8CD9)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT",SWIG_From_int(static_cast< int >(0x8CDA)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT",SWIG_From_int(static_cast< int >(0x8CDB)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT",SWIG_From_int(static_cast< int >(0x8CDC)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_UNSUPPORTED_EXT",SWIG_From_int(static_cast< int >(0x8CDD)));
  SWIG_Python_SetConstant(d, "GL_MAX_COLOR_ATTACHMENTS_EXT",SWIG_From_int(static_cast< int >(0x8CDF)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT0_EXT",SWIG_From_int(static_cast< int >(0x8CE0)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT1_EXT",SWIG_From_int(static_cast< int >(0x8CE1)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT2_EXT",SWIG_From_int(static_cast< int >(0x8CE2)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT3_EXT",SWIG_From_int(static_cast< int >(0x8CE3)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT4_EXT",SWIG_From_int(static_cast< int >(0x8CE4)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT5_EXT",SWIG_From_int(static_cast< int >(0x8CE5)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT6_EXT",SWIG_From_int(static_cast< int >(0x8CE6)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT7_EXT",SWIG_From_int(static_cast< int >(0x8CE7)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT8_EXT",SWIG_From_int(static_cast< int >(0x8CE8)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT9_EXT",SWIG_From_int(static_cast< int >(0x8CE9)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT10_EXT",SWIG_From_int(static_cast< int >(0x8CEA)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT11_EXT",SWIG_From_int(static_cast< int >(0x8CEB)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT12_EXT",SWIG_From_int(static_cast< int >(0x8CEC)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT13_EXT",SWIG_From_int(static_cast< int >(0x8CED)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT14_EXT",SWIG_From_int(static_cast< int >(0x8CEE)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT15_EXT",SWIG_From_int(static_cast< int >(0x8CEF)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_ATTACHMENT_EXT",SWIG_From_int(static_cast< int >(0x8D00)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_ATTACHMENT_EXT",SWIG_From_int(static_cast< int >(0x8D20)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_EXT",SWIG_From_int(static_cast< int >(0x8D40)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_EXT",SWIG_From_int(static_cast< int >(0x8D41)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_WIDTH_EXT",SWIG_From_int(static_cast< int >(0x8D42)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_HEIGHT_EXT",SWIG_From_int(static_cast< int >(0x8D43)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT",SWIG_From_int(static_cast< int >(0x8D44)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX1_EXT",SWIG_From_int(static_cast< int >(0x8D46)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX4_EXT",SWIG_From_int(static_cast< int >(0x8D47)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX8_EXT",SWIG_From_int(static_cast< int >(0x8D48)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX16_EXT",SWIG_From_int(static_cast< int >(0x8D49)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_RED_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D50)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_GREEN_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D51)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_BLUE_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D52)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_ALPHA_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D53)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_DEPTH_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D54)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_STENCIL_SIZE_EXT",SWIG_From_int(static_cast< int >(0x8D55)));
  SWIG_Python_SetConstant(d, "GL_INVALID_FRAMEBUFFER_OPERATION",SWIG_From_int(static_cast< int >(0x0506)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING",SWIG_From_int(static_cast< int >(0x8210)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE",SWIG_From_int(static_cast< int >(0x8211)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE",SWIG_From_int(static_cast< int >(0x8212)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",SWIG_From_int(static_cast< int >(0x8213)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",SWIG_From_int(static_cast< int >(0x8214)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",SWIG_From_int(static_cast< int >(0x8215)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",SWIG_From_int(static_cast< int >(0x8216)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",SWIG_From_int(static_cast< int >(0x8217)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_STENCIL",SWIG_From_int(static_cast< int >(0x84F9)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_INT_24_",SWIG_From_int(static_cast< int >(0x84FA)));
  SWIG_Python_SetConstant(d, "GL_DEPTH24_STENCIL8",SWIG_From_int(static_cast< int >(0x88F0)));
  SWIG_Python_SetConstant(d, "GL_TEXTURE_STENCIL_SIZE",SWIG_From_int(static_cast< int >(0x88F1)));
  SWIG_Python_SetConstant(d, "GL_SRGB",SWIG_From_int(static_cast< int >(0x8C40)));
  SWIG_Python_SetConstant(d, "GL_UNSIGNED_NORMALIZED",SWIG_From_int(static_cast< int >(0x8C17)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_DEFAULT",SWIG_From_int(static_cast< int >(0x8218)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_UNDEFINED",SWIG_From_int(static_cast< int >(0x8219)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_STENCIL_ATTACHMENT",SWIG_From_int(static_cast< int >(0x821A)));
  SWIG_Python_SetConstant(d, "GL_INDEX",SWIG_From_int(static_cast< int >(0x8222)));
  SWIG_Python_SetConstant(d, "GL_MAX_RENDERBUFFER_SIZE",SWIG_From_int(static_cast< int >(0x84E8)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_BINDING",SWIG_From_int(static_cast< int >(0x8CA6)));
  SWIG_Python_SetConstant(d, "GL_DRAW_FRAMEBUFFER_BINDING",SWIG_From_int(static_cast< int >(0x8CA6)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_BINDING",SWIG_From_int(static_cast< int >(0x8CA7)));
  SWIG_Python_SetConstant(d, "GL_READ_FRAMEBUFFER",SWIG_From_int(static_cast< int >(0x8CA8)));
  SWIG_Python_SetConstant(d, "GL_DRAW_FRAMEBUFFER",SWIG_From_int(static_cast< int >(0x8CA9)));
  SWIG_Python_SetConstant(d, "GL_READ_FRAMEBUFFER_BINDING",SWIG_From_int(static_cast< int >(0x8CAA)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_SAMPLES",SWIG_From_int(static_cast< int >(0x8CAB)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",SWIG_From_int(static_cast< int >(0x8CD0)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",SWIG_From_int(static_cast< int >(0x8CD1)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",SWIG_From_int(static_cast< int >(0x8CD2)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",SWIG_From_int(static_cast< int >(0x8CD3)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER",SWIG_From_int(static_cast< int >(0x8CD4)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET",SWIG_From_int(static_cast< int >(0x8CD4)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_COMPLETE",SWIG_From_int(static_cast< int >(0x8CD5)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",SWIG_From_int(static_cast< int >(0x8CD6)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",SWIG_From_int(static_cast< int >(0x8CD7)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT",SWIG_From_int(static_cast< int >(0x8CD8)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",SWIG_From_int(static_cast< int >(0x8CDB)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",SWIG_From_int(static_cast< int >(0x8CDC)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_UNSUPPORTED",SWIG_From_int(static_cast< int >(0x8CDD)));
  SWIG_Python_SetConstant(d, "GL_MAX_COLOR_ATTACHMENTS",SWIG_From_int(static_cast< int >(0x8CDF)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT0",SWIG_From_int(static_cast< int >(0x8CE0)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT1",SWIG_From_int(static_cast< int >(0x8CE1)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT2",SWIG_From_int(static_cast< int >(0x8CE2)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT3",SWIG_From_int(static_cast< int >(0x8CE3)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT4",SWIG_From_int(static_cast< int >(0x8CE4)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT5",SWIG_From_int(static_cast< int >(0x8CE5)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT6",SWIG_From_int(static_cast< int >(0x8CE6)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT7",SWIG_From_int(static_cast< int >(0x8CE7)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT8",SWIG_From_int(static_cast< int >(0x8CE8)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT9",SWIG_From_int(static_cast< int >(0x8CE9)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT10",SWIG_From_int(static_cast< int >(0x8CEA)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT11",SWIG_From_int(static_cast< int >(0x8CEB)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT12",SWIG_From_int(static_cast< int >(0x8CEC)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT13",SWIG_From_int(static_cast< int >(0x8CED)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT14",SWIG_From_int(static_cast< int >(0x8CEE)));
  SWIG_Python_SetConstant(d, "GL_COLOR_ATTACHMENT15",SWIG_From_int(static_cast< int >(0x8CEF)));
  SWIG_Python_SetConstant(d, "GL_DEPTH_ATTACHMENT",SWIG_From_int(static_cast< int >(0x8D00)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_ATTACHMENT",SWIG_From_int(static_cast< int >(0x8D20)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER",SWIG_From_int(static_cast< int >(0x8D40)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER",SWIG_From_int(static_cast< int >(0x8D41)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_WIDTH",SWIG_From_int(static_cast< int >(0x8D42)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_HEIGHT",SWIG_From_int(static_cast< int >(0x8D43)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_INTERNAL_FORMAT",SWIG_From_int(static_cast< int >(0x8D44)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX1",SWIG_From_int(static_cast< int >(0x8D46)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX4",SWIG_From_int(static_cast< int >(0x8D47)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX8",SWIG_From_int(static_cast< int >(0x8D48)));
  SWIG_Python_SetConstant(d, "GL_STENCIL_INDEX16",SWIG_From_int(static_cast< int >(0x8D49)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_RED_SIZE",SWIG_From_int(static_cast< int >(0x8D50)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_GREEN_SIZE",SWIG_From_int(static_cast< int >(0x8D51)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_BLUE_SIZE",SWIG_From_int(static_cast< int >(0x8D52)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_ALPHA_SIZE",SWIG_From_int(static_cast< int >(0x8D53)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_DEPTH_SIZE",SWIG_From_int(static_cast< int >(0x8D54)));
  SWIG_Python_SetConstant(d, "GL_RENDERBUFFER_STENCIL_SIZE",SWIG_From_int(static_cast< int >(0x8D55)));
  SWIG_Python_SetConstant(d, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE",SWIG_From_int(static_cast< int >(0x8D56)));
  SWIG_Python_SetConstant(d, "GL_MAX_SAMPLES",SWIG_From_int(static_cast< int >(0x8D57)));
  SWIG_Python_SetConstant(d, "GL_NUM_EXTENSIONS",SWIG_From_int(static_cast< int >(0x821D)));
  SWIG_Python_SetConstant(d, "GLX_PBUFFER_WIDTH",SWIG_From_int(static_cast< int >(0x8041)));
  SWIG_Python_SetConstant(d, "GLX_PBUFFER_HEIGHT",SWIG_From_int(static_cast< int >(0x8040)));
  SWIG_Python_SetConstant(d, "GLX_DRAWABLE_TYPE",SWIG_From_int(static_cast< int >(0x8010)));
  SWIG_Python_SetConstant(d, "GLX_RENDER_TYPE",SWIG_From_int(static_cast< int >(0x8011)));
  SWIG_Python_SetConstant(d, "GLX_RGBA_TYPE",SWIG_From_int(static_cast< int >(0x8014)));
  SWIG_Python_SetConstant(d, "GLX_RGBA_BIT",SWIG_From_int(static_cast< int >(0x00000001)));
  SWIG_Python_SetConstant(d, "GLX_PBUFFER_BIT",SWIG_From_int(static_cast< int >(0x00000004)));
  SWIG_Python_SetConstant(d, "GLX_MAX_PBUFFER_WIDTH",SWIG_From_int(static_cast< int >(0x8016)));
  SWIG_Python_SetConstant(d, "GLX_MAX_PBUFFER_HEIGHT",SWIG_From_int(static_cast< int >(0x8017)));
  SWIG_Python_SetConstant(d, "GLX_MAX_PBUFFER_PIXELS",SWIG_From_int(static_cast< int >(0x8018)));
  SWIG_Python_SetConstant(d, "GLU_VERSION",SWIG_From_int(static_cast< int >(100800)));
  SWIG_Python_SetConstant(d, "GLU_EXTENSIONS",SWIG_From_int(static_cast< int >(100801)));
  SWIG_Python_SetConstant(d, "GLU_OUTLINE_POLYGON",SWIG_From_int(static_cast< int >(100240)));
  SWIG_Python_SetConstant(d, "GLU_OUTLINE_PATCH",SWIG_From_int(static_cast< int >(100241)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_ERROR",SWIG_From_int(static_cast< int >(100103)));
  SWIG_Python_SetConstant(d, "GLU_ERROR",SWIG_From_int(static_cast< int >(100103)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_BEGIN",SWIG_From_int(static_cast< int >(100164)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_VERTEX",SWIG_From_int(static_cast< int >(100165)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_NORMAL",SWIG_From_int(static_cast< int >(100166)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_COLOR",SWIG_From_int(static_cast< int >(100167)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_TEXTURE_COORD",SWIG_From_int(static_cast< int >(100168)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_END",SWIG_From_int(static_cast< int >(100169)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_BEGIN_DATA",SWIG_From_int(static_cast< int >(100170)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_VERTEX_DATA",SWIG_From_int(static_cast< int >(100171)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_NORMAL_DATA",SWIG_From_int(static_cast< int >(100172)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_COLOR_DATA",SWIG_From_int(static_cast< int >(100173)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_TEXTURE_COORD_DATA",SWIG_From_int(static_cast< int >(100174)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_END_DATA",SWIG_From_int(static_cast< int >(100175)));
  SWIG_Python_SetConstant(d, "GLU_AUTO_LOAD_MATRIX",SWIG_From_int(static_cast< int >(100200)));
  SWIG_Python_SetConstant(d, "GLU_CULLING",SWIG_From_int(static_cast< int >(100201)));
  SWIG_Python_SetConstant(d, "GLU_SAMPLING_TOLERANCE",SWIG_From_int(static_cast< int >(100203)));
  SWIG_Python_SetConstant(d, "GLU_DISPLAY_MODE",SWIG_From_int(static_cast< int >(100204)));
  SWIG_Python_SetConstant(d, "GLU_PARAMETRIC_TOLERANCE",SWIG_From_int(static_cast< int >(100202)));
  SWIG_Python_SetConstant(d, "GLU_SAMPLING_METHOD",SWIG_From_int(static_cast< int >(100205)));
  SWIG_Python_SetConstant(d, "GLU_U_STEP",SWIG_From_int(static_cast< int >(100206)));
  SWIG_Python_SetConstant(d, "GLU_V_STEP",SWIG_From_int(static_cast< int >(100207)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_MODE",SWIG_From_int(static_cast< int >(100160)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_TESSELLATOR",SWIG_From_int(static_cast< int >(100161)));
  SWIG_Python_SetConstant(d, "GLU_NURBS_RENDERER",SWIG_From_int(static_cast< int >(100162)));
  SWIG_Python_SetConstant(d, "GLU_OBJECT_PARAMETRIC_ERROR",SWIG_From_int(static_cast< int >(100208)));
  SWIG_Python_SetConstant(d, "GLU_OBJECT_PATH_LENGTH",SWIG_From_int(static_cast< int >(100209)));
  SWIG_Python_SetConstant(d, "GLU_PATH_LENGTH",SWIG_From_int(static_cast< int >(100215)));
  SWIG_Python_SetConstant(d, "GLU_PARAMETRIC_ERROR",SWIG_From_int(static_cast< int >(100216)));
  SWIG_Python_SetConstant(d, "GLU_DOMAIN_DISTANCE",SWIG_From_int(static_cast< int >(100217)));
  SWIG_Python_SetConstant(d, "GLU_MAP1_TRIM_2",SWIG_From_int(static_cast< int >(100210)));
  SWIG_Python_SetConstant(d, "GLU_MAP1_TRIM_3",SWIG_From_int(static_cast< int >(100211)));
  SWIG_Python_SetConstant(d, "GLU_POINT",SWIG_From_int(static_cast< int >(100010)));
  SWIG_Python_SetConstant(d, "GLU_LINE",SWIG_From_int(static_cast< int >(100011)));
  SWIG_Python_SetConstant(d, "GLU_FILL",SWIG_From_int(static_cast< int >(100012)));
  SWIG_Python_SetConstant(d, "GLU_SILHOUETTE",SWIG_From_int(static_cast< int >(100013)));
  SWIG_Python_SetConstant(d, "GLU_TESS_BEGIN",SWIG_From_int(static_cast< int >(100100)));
  SWIG_Python_SetConstant(d, "GLU_TESS_VERTEX",SWIG_From_int(static_cast< int >(100101)));
  SWIG_Python_SetConstant(d, "GLU_TESS_END",SWIG_From_int(static_cast< int >(100102)));
  SWIG_Python_SetConstant(d, "GLU_TESS_ERROR",SWIG_From_int(static_cast< int >(100103)));
  SWIG_Python_SetConstant(d, "GLU_TESS_COMBINE",SWIG_From_int(static_cast< int >(100105)));
  SWIG_Python_SetConstant(d, "GLU_TESS_BEGIN_DATA",SWIG_From_int(static_cast< int >(100106)));
  SWIG_Python_SetConstant(d, "GLU_TESS_VERTEX_DATA",SWIG_From_int(static_cast< int >(100107)));
  SWIG_Python_SetConstant(d, "GLU_TESS_END_DATA",SWIG_From_int(static_cast< int >(100108)));
  SWIG_Python_SetConstant(d, "GLU_TESS_ERROR_DATA",SWIG_From_int(static_cast< int >(100109)));
  SWIG_Python_SetConstant(d, "GLU_TESS_MISSING_BEGIN_POLYGON",SWIG_From_int(static_cast< int >(100151)));
  SWIG_Python_SetConstant(d, "GLU_TESS_MISSING_BEGIN_CONTOUR",SWIG_From_int(static_cast< int >(100152)));
  SWIG_Python_SetConstant(d, "GLU_TESS_MISSING_END_POLYGON",SWIG_From_int(static_cast< int >(100153)));
  SWIG_Python_SetConstant(d, "GLU_TESS_MISSING_END_CONTOUR",SWIG_From_int(static_cast< int >(100154)));
  SWIG_Python_SetConstant(d, "GLU_TESS_NEED_COMBINE_CALLBACK",SWIG_From_int(static_cast< int >(100156)));
  SWIG_Python_SetConstant(d, "WGL_COLOR_BITS_ARB",SWIG_From_int(static_cast< int >(0x2014)));
  SWIG_Python_SetConstant(d, "WGL_ALPHA_BITS_ARB",SWIG_From_int(static_cast< int >(0x201B)));
  SWIG_Python_SetConstant(d, "WGL_DEPTH_BITS_ARB",SWIG_From_int(static_cast< int >(0x2022)));
  SWIG_Python_SetConstant(d, "WGL_STENCIL_BITS_ARB",SWIG_From_int(static_cast< int >(0x2023)));
  SWIG_Python_SetConstant(d, "WGL_DRAW_TO_PBUFFER_ARB",SWIG_From_int(static_cast< int >(0x202D)));
  SWIG_Python_SetConstant(d, "WGL_PBUFFER_WIDTH_ARB",SWIG_From_int(static_cast< int >(0x2034)));
  SWIG_Python_SetConstant(d, "WGL_PBUFFER_HEIGHT_ARB",SWIG_From_int(static_cast< int >(0x2035)));
  SWIG_Python_SetConstant(d, "WGL_BIND_TO_TEXTURE_RGB_ARB",SWIG_From_int(static_cast< int >(0x2070)));
  SWIG_Python_SetConstant(d, "WGL_BIND_TO_TEXTURE_RGBA_ARB",SWIG_From_int(static_cast< int >(0x2071)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_FORMAT_ARB",SWIG_From_int(static_cast< int >(0x2072)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_TARGET_ARB",SWIG_From_int(static_cast< int >(0x2073)));
  SWIG_Python_SetConstant(d, "WGL_MIPMAP_TEXTURE_ARB",SWIG_From_int(static_cast< int >(0x2074)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_RGB_ARB",SWIG_From_int(static_cast< int >(0x2075)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_RGBA_ARB",SWIG_From_int(static_cast< int >(0x2076)));
  SWIG_Python_SetConstant(d, "WGL_NO_TEXTURE_ARB",SWIG_From_int(static_cast< int >(0x2077)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_CUBE_MAP_ARB",SWIG_From_int(static_cast< int >(0x2078)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_1D_ARB",SWIG_From_int(static_cast< int >(0x2079)));
  SWIG_Python_SetConstant(d, "WGL_TEXTURE_2D_ARB",SWIG_From_int(static_cast< int >(0x207A)));
  SWIG_Python_SetConstant(d, "WGL_MIPMAP_LEVEL_ARB",SWIG_From_int(static_cast< int >(0x207B)));
  SWIG_Python_SetConstant(d, "WGL_FRONT_LEFT_ARB",SWIG_From_int(static_cast< int >(0x2083)));
  SWIG_Python_SetConstant(d, "WGL_FRONT_RIGHT_ARB",SWIG_From_int(static_cast< int >(0x2084)));
  SWIG_Python_SetConstant(d, "WGL_BACK_LEFT_ARB",SWIG_From_int(static_cast< int >(0x2085)));
  SWIG_Python_SetConstant(d, "WGL_BACK_RIGHT_ARB",SWIG_From_int(static_cast< int >(0x2086)));
  SWIG_Python_SetConstant(d, "WGL_MAX_PBUFFER_PIXELS_ARB",SWIG_From_int(static_cast< int >(0x202E)));
  SWIG_Python_SetConstant(d, "WGL_MAX_PBUFFER_WIDTH_ARB",SWIG_From_int(static_cast< int >(0x202F)));
  SWIG_Python_SetConstant(d, "WGL_MAX_PBUFFER_HEIGHT_ARB",SWIG_From_int(static_cast< int >(0x2030)));
  SWIG_Python_SetConstant(d, "SbRWMutex_READ_PRECEDENCE",SWIG_From_int(static_cast< int >(SbRWMutex::READ_PRECEDENCE)));
  SWIG_Python_SetConstant(d, "SbRWMutex_WRITE_PRECEDENCE",SWIG_From_int(static_cast< int >(SbRWMutex::WRITE_PRECEDENCE)));
  SWIG_Python_SetConstant(d, "SoVRMLGroup_OFF",SWIG_From_int(static_cast< int >(SoVRMLGroup::OFF)));
  SWIG_Python_SetConstant(d, "SoVRMLGroup_ON",SWIG_From_int(static_cast< int >(SoVRMLGroup::ON)));
  SWIG_Python_SetConstant(d, "SoVRMLGroup_AUTO",SWIG_From_int(static_cast< int >(SoVRMLGroup::AUTO)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_SERIF",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::SERIF)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_SANS",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::SANS)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_TYPEWRITER",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::TYPEWRITER)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_PLAIN",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::PLAIN)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_BOLD",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::BOLD)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_ITALIC",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::ITALIC)));
  SWIG_Python_SetConstant(d, "SoVRMLFontStyle_BOLDITALIC",SWIG_From_int(static_cast< int >(SoVRMLFontStyle::BOLDITALIC)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_OVERALL",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::OVERALL)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_PART",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_PART)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_PART_INDEXED",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_PART_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_FACE",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_FACE)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_FACE_INDEXED",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_FACE_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_VERTEX",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_VERTEX)));
  SWIG_Python_SetConstant(d, "SoVRMLVertexShape_PER_VERTEX_INDEXED",SWIG_From_int(static_cast< int >(SoVRMLVertexShape::PER_VERTEX_INDEXED)));
  SWIG_Python_SetConstant(d, "SoVRMLInline_NEVER",SWIG_From_int(static_cast< int >(SoVRMLInline::NEVER)));
  SWIG_Python_SetConstant(d, "SoVRMLInline_UNTIL_LOADED",SWIG_From_int(static_cast< int >(SoVRMLInline::UNTIL_LOADED)));
  SWIG_Python_SetConstant(d, "SoVRMLInline_ALWAYS",SWIG_From_int(static_cast< int >(SoVRMLInline::ALWAYS)));
  SWIG_Python_SetConstant(d, "SoVRMLShape_OFF",SWIG_From_int(static_cast< int >(SoVRMLShape::OFF)));
  SWIG_Python_SetConstant(d, "SoVRMLShape_ON",SWIG_From_int(static_cast< int >(SoVRMLShape::ON)));
  SWIG_Python_SetConstant(d, "SoVRMLShape_AUTO",SWIG_From_int(static_cast< int >(SoVRMLShape::AUTO)));
  SWIG_Python_SetConstant(d, "SoVRMLText_BEGIN",SWIG_From_int(static_cast< int >(SoVRMLText::BEGIN)));
  SWIG_Python_SetConstant(d, "SoVRMLText_END",SWIG_From_int(static_cast< int >(SoVRMLText::END)));
  SWIG_Python_SetConstant(d, "SoVRMLText_MIDDLE",SWIG_From_int(static_cast< int >(SoVRMLText::MIDDLE)));
  SWIG_Python_SetConstant(d, "SoEventManager_NO_NAVIGATION",SWIG_From_int(static_cast< int >(SoEventManager::NO_NAVIGATION)));
  SWIG_Python_SetConstant(d, "SoEventManager_JUST_NAVIGATION",SWIG_From_int(static_cast< int >(SoEventManager::JUST_NAVIGATION)));
  SWIG_Python_SetConstant(d, "SoEventManager_MIXED_NAVIGATION",SWIG_From_int(static_cast< int >(SoEventManager::MIXED_NAVIGATION)));
  SWIG_Python_SetConstant(d, "SoRenderManager_AS_IS",SWIG_From_int(static_cast< int >(SoRenderManager::AS_IS)));
  SWIG_Python_SetConstant(d, "SoRenderManager_WIREFRAME",SWIG_From_int(static_cast< int >(SoRenderManager::WIREFRAME)));
  SWIG_Python_SetConstant(d, "SoRenderManager_POINTS",SWIG_From_int(static_cast< int >(SoRenderManager::POINTS)));
  SWIG_Python_SetConstant(d, "SoRenderManager_WIREFRAME_OVERLAY",SWIG_From_int(static_cast< int >(SoRenderManager::WIREFRAME_OVERLAY)));
  SWIG_Python_SetConstant(d, "SoRenderManager_HIDDEN_LINE",SWIG_From_int(static_cast< int >(SoRenderManager::HIDDEN_LINE)));
  SWIG_Python_SetConstant(d, "SoRenderManager_BOUNDING_BOX",SWIG_From_int(static_cast< int >(SoRenderManager::BOUNDING_BOX)));
  SWIG_Python_SetConstant(d, "SoRenderManager_SHADED_HIDDEN_LINES",SWIG_From_int(static_cast< int >(SoRenderManager::SHADED_HIDDEN_LINES)));
  SWIG_Python_SetConstant(d, "SoRenderManager_MONO",SWIG_From_int(static_cast< int >(SoRenderManager::MONO)));
  SWIG_Python_SetConstant(d, "SoRenderManager_ANAGLYPH",SWIG_From_int(static_cast< int >(SoRenderManager::ANAGLYPH)));
  SWIG_Python_SetConstant(d, "SoRenderManager_SEPARATE_OUTPUT",SWIG_From_int(static_cast< int >(SoRenderManager::SEPARATE_OUTPUT)));
  SWIG_Python_SetConstant(d, "SoRenderManager_QUAD_BUFFER",SWIG_From_int(static_cast< int >(SoRenderManager::QUAD_BUFFER)));
  SWIG_Python_SetConstant(d, "SoRenderManager_INTERLEAVED_ROWS",SWIG_From_int(static_cast< int >(SoRenderManager::INTERLEAVED_ROWS)));
  SWIG_Python_SetConstant(d, "SoRenderManager_INTERLEAVED_COLUMNS",SWIG_From_int(static_cast< int >(SoRenderManager::INTERLEAVED_COLUMNS)));
  SWIG_Python_SetConstant(d, "SoRenderManager_BUFFER_SINGLE",SWIG_From_int(static_cast< int >(SoRenderManager::BUFFER_SINGLE)));
  SWIG_Python_SetConstant(d, "SoRenderManager_BUFFER_DOUBLE",SWIG_From_int(static_cast< int >(SoRenderManager::BUFFER_DOUBLE)));
  SWIG_Python_SetConstant(d, "SoRenderManager_NO_AUTO_CLIPPING",SWIG_From_int(static_cast< int >(SoRenderManager::NO_AUTO_CLIPPING)));
  SWIG_Python_SetConstant(d, "SoRenderManager_FIXED_NEAR_PLANE",SWIG_From_int(static_cast< int >(SoRenderManager::FIXED_NEAR_PLANE)));
  SWIG_Python_SetConstant(d, "SoRenderManager_VARIABLE_NEAR_PLANE",SWIG_From_int(static_cast< int >(SoRenderManager::VARIABLE_NEAR_PLANE)));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation"));
  SWIG_Python_SetConstant(d, "SOSCXML_NAVIGATION_TARGETTYPE",SWIG_FromCharPtr("x-coin-navigation"));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_PAN_TARGET_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation.Pan"));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_ROTATE_TARGET_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation.Rotate"));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_SEEK_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation.Seek"));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_SPIN_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation.Spin"));
  SWIG_Python_SetConstant(d, "COIN_NAVIGATION_ZOOM_TARGET_EVENT_PREFIX",SWIG_FromCharPtr("x-coin-navigation.Zoom"));
  SWIG_addvarlink(globals, "SoSearchAction_duringSearchAll", Swig_var_SoSearchAction_duringSearchAll_get, Swig_var_SoSearchAction_duringSearchAll_set);
  return 0;
}

